// WE KNOW THAT  :   lcm(x,y)= (x*y)/gcd(x,y)


package Recursion;
import java.util.Scanner;


public class RecLCM {

     public static int lcm(int x,int y){

          if(y==0) return x;
          return lcm(y,x%y);
     }

     public static void main(String[] args) {

          Scanner sc=new Scanner(System.in);
          System.out.println("Enter x and y: ");
          int x=sc.nextInt();
          int y=sc.nextInt();
          int ans=lcm(x,y);
          System.out.println("LCM of "+x+" and "+y+" is: "+(x*y)/ans);


          sc.close();
     }

}

import random

def guess_the_number():
    number_to_guess = random.randint(1, 100)
    attempts = 0
    while True:
        guess = int(input("Guess the number (1-100): "))
        attempts += 1
        if guess < number_to_guess:
            print("Too low!")
        elif guess > number_to_guess:
            print("Too high!")
        else:
            print(f"Congratulations! You guessed the number in {attempts} attempts.")
            break

guess_the_number()

/* Add .pa-bullet-list-check as class in text module */
.pa-bullet-list-check ul {
list-style-type: none!important;
}
.pa-bullet-list-check ul li:before {
content: '\4e'!important;
color: #787F84;
font-family: 'ETMODULES'!important;
margin-right: 0.5vw;
margin-left: -1vw;
font-size: 1.27vw!important;
}

#include <iostream>
using namespace std;

int main() {
  int arr[10] = {23 , 122 , 41, 67};
  cout << arr << endl;
  cout << &arr[0] << endl;
  cout << *arr << endl; 
  cout << *(arr) << endl; 
  cout << *(arr+1) << endl;
  cout << *(arr) + 4 << endl;
  cout << arr[2] << endl;
  cout << *(arr+2) << endl;
  

  
  
    return 0;
}

#include <iostream>
using namespace std;

int main() {
  int arr[10] = {23 , 122 , 41, 67};

  int n[10];
   cout << sizeof(n) << endl;
   
   int *p = &n[5];
    cout << sizeof(*p) << endl;
    cout << sizeof(p) << endl;
     cout << sizeof(&p) << endl;
  
  

  
  
    return 0;
}

#include <iostream>
using namespace std;

int main() {
  int arr[10] = {23 , 122 , 41, 67};
  cout << arr << endl;
  cout << &arr[0] << endl;
  cout << *arr << endl; 
  cout << *(arr) << endl; 
  cout << *(arr+1) << endl;
  cout << *(arr) + 4 << endl;
  cout << arr[2] << endl;
  cout << *(arr+2) << endl;
  

  
  
    return 0;
}

git remote add origin https://github.com/Code2Buzz/PyTorch.git
git branch -M main
git push -u origin main

echo "# PyTorch" >> README.md
git init
git add README.md
git commit -m "first commit"
git branch -M main
git remote add origin https://github.com/Code2Buzz/PyTorch.git
git push -u origin main

#Sort a list without using sort()
def sort_list(nums):
    sorted_list = []
    while nums:
        minimum = min(nums)
        sorted_list.append(minimum)
        nums.remove(minimum)
    return sorted_list

numbers = [5, 3, 8, 2, 7]
sorted_numbers = sort_list(numbers)
print(f"Sorted list: {sorted_numbers}")

numbers = [5, 3, 8, 2, 7]

# Find max and min
max_number = max(numbers)
min_number = min(numbers)

print(f"Max: {max_number}, Min: {min_number}")

grades = {}

# Add student grades
grades["Emily"] = 88
grades["James"] = 76
grades["Olivia"] = 92

# Print all students and their grades
for student, grade in grades.items():
    print(f"{student}: {grade}")

# Create a dictionary - paired values
student_grades = {
    "Alice": 90,
    "Bob": 85,
    "Charlie": 92
}

# Access and modify
print(student_grades["Alice"])
student_grades["Bob"] = 88  # Update Bob's grade

# Add a new entry
student_grades["Dave"] = 95

print(student_grades)

favorite_movies = []

# Add movies
favorite_movies.append("The Godfather")
favorite_movies.append("Pulp Fiction")

# Remove a movie
favorite_movies.remove("Pulp Fiction")

# Print the list
print(f"My favorite movies: {favorite_movies}")

# Lists
movies = ["Inception", "The Matrix", "Interstellar"]
movies.append("The Shawshank Redemption")
movies.remove("The Matrix")

# Access elements
print(movies[0])  # First element

# Tuples (immutable)
dimensions = (1920, 1080)
print(dimensions[1])  # Access element

def multiply_numbers(x, y):
    return x * y

num1 = int(input("Enter first number: "))
num2 = int(input("Enter second number: "))

result = multiply_numbers(num1, num2)
print(f"The product of {num1} and {num2} is {result}.")

def multiply(a, b):
    return a * b

result = multiply(5, 4)
print(f"Multiplication result: {result}")

a = 5
b = 4
def multiply():
    return a * b
print(multiply())

# Using a while loop
sum_numbers = 0
num = 1

while num <= 100:
    sum_numbers += num
    num += 1

print(f"Sum of numbers 1 to 100: {sum_numbers}")

for i in range(1, 10):
    print(i)

/////////////// Inserting Record into Middle Table ///////
				importList = List();
				for each  id in uniqueIDs
				{
					if(!isNull(id))
					{
						rowMap = Map();
						rowMap.put("Unique String",id);
						rowMap.put("Invoice ID",invoiceID);
						importList.add(rowMap);
					}
				}
				////////////////////////////////////////////////////////////////
				viewName2 = "Invoices Centre Table";
				paramsMap = Map();
				paramsMap.put("ZOHO_ACTION","IMPORT");
				paramsMap.put("ZOHO_OUTPUT_FORMAT","JSON");
				paramsMap.put("ZOHO_ERROR_FORMAT","JSON");
				paramsMap.put("ZOHO_API_VERSION","1.0");
				//=========================================
				//ACTION SPECIFIC PARAMS
				paramsMap.put("ZOHO_IMPORT_DATA",importList);
				paramsMap.put("ZOHO_IMPORT_FILETYPE","JSON");
				paramsMap.put("ZOHO_IMPORT_TYPE","UPDATEADD");
				paramsMap.put("ZOHO_AUTO_IDENTIFY","TRUE");
				paramsMap.put("ZOHO_ON_IMPORT_ERROR","SKIPROW");
				paramsMap.put("ZOHO_CREATE_TABLE","false");
				paramsMap.put("ZOHO_MATCHING_COLUMNS","Unique String");
				// ==========================================
				importInvoicedItems = invokeurl
				[
					url :"https://analytics.zoho.com//api/" + encodeUrl(email) + "/" + encodeUrl(workspaceName) + "/" + encodeUrl(viewName2) + ""
					type :POST
					parameters:paramsMap
					connection:"zoho_apps_connection"
				];
				info "Adding to Middle Table: " + importInvoicedItems;

for i in range(10):
    print(i)

age = int(input("Enter your age: "))

if age < 13:
    print("You are a child.")
elif 13 <= age < 20:
    print("You are a teenager.")
elif 20 <= age < 60:
    print("You are an adult.")
else:
    print("You are a senior.")

age = int(input("Enter your age: "))

if age < 18:

    print("You are a minor.")
elif 18 <= age < 65:
    print("You are an adult.")
else:
    print("You are a senior citizen.")

#Basic operators: + - * / // % **
a = 10
b = 3

addition = a + b
subtraction = a - b
multiplication = a * b
division = a / b
floor_division = a // b
modulus = a % b
exponentiation = a ** b

print(addition, subtraction, multiplication, division, floor_division, modulus, exponentiation)

Every online business needs a perfect payment gateway for their business. During the crypto wave's emergence, a lot of payment gateways arise. Particularly, Bitpay is a more famous one in the competitive market. Because many entrepreneurs want to implement Bitpay clone scripts in their payment gateway businesses.

1. The primary function of crypto payment is used for merchants and individuals.
2. Permit any users who can connect their crypto wallet to the platform for making a seamless transaction.
3. Support a wide range of cryptocurrencies and fiat currencies. These supporting factors will lead to more engagement and user enticement to use your platform.
4. Allowing your merchants to generate an invoice, and accepting crypto payments.
5. Build a robust API to integrate with other platforms and services.
6. Escrow Services: Facilitate secure transactions by holding funds in escrow until conditions are met.
7. Recurring Payments: Allow for automated recurring payments.
8. Mass Payouts: Enable merchants to make bulk payments to multiple recipients.
9. Fiat On/Off Ramp: Integrate with fiat payment gateways to allow users to buy and sell cryptocurrencies.
10. Merchant Dashboard: Provide merchants with a dashboard for managing transactions, invoices, and analytics.
11. Security Features: Implement robust security measures to protect user data and prevent fraud.

These are the worthwhile features that resonate with break-throwing business tactics to build your business to robust security standards. So if you're looking to start your business using a Bitpay clone script, then Appticz is the right place to develop your business with top-notch quality.

name = input("Enter your name: ")
age = int(input("Enter your age: "))
print(f"Hello, {name}! You are {age} years old.")

# Create variables
username = "JohnDoe"
user_age = 25
balance = 150.75
is_member = False

# Manipulate and print variables
new_balance = balance + 100
print (f"Username: {username}, Age: {user_age}")
print (f"Hi {username} you are {user_age} and your balance is {new_balance}")

# Create variables
username = "JohnDoe"
user_age = 25
balance = 150.75
is_member = False

# Manipulate and print variables
new_balance = balance + 100

print("Username:", username)
print("Age:", user_age)
print("New Balance:", new_balance)
print("Is Member:", is_member)

# Create variables
userfirstname = "John"
userlastname = "Doe"
user_age = 25

print(username, user_age)
print(userfirstname + userlastname) #concatenate
print("Hello " + userfirstname + " " + userlastname) #concatenate with spaces

# Variables
name = "Alice"        # String
age = 30              # Integer
height = 5.7          # Float
is_student = True     # Boolean

# Print variable values
print(name)
print(age)
print(height)
print(is_student)

print("Hello, World!")

const express = require('express');
const app = express();
const bodyParser = require('body-parser');

app.use(bodyParser.json());

app.post('/login', (req, res) => {
    const { username, password } = req.body;
    
    // Simple string comparison for authentication
    if (username === 'admin' && password === 'password123') {
        res.send({ message: 'Login successful!', token: 'fake-jwt-token' });
    } else {
        res.status(401).send({ message: 'Invalid credentials' });
    }
});

app.listen(3000, () => {
    console.log('Server running on port 3000');
});

import clickhouse_connect

client = clickhouse_connect.get_client(host='localhost', username='default', password='atlife789')

def execute_query(client,trans_query):
    try:
        data = client.query(trans_query)
        dataset = pd.DataFrame(data.result_rows,columns=data.column_names)
        return dataset
    except Exception as e:
        print(f'Erron on executing the query as {e}.')
        return pd.DataFrame()

import ctypes
from ctypes import wintypes
 
# Definition der winmm.dll Funktionen
winmm = ctypes.WinDLL('winmm')
 
# Definieren der mciSendString Funktion
mciSendString = winmm.mciSendStringW
mciSendString.argtypes = [wintypes.LPCWSTR, wintypes.LPWSTR, wintypes.UINT, wintypes.HWND]
mciSendString.restype = wintypes.UINT
 
def main():
    while True:
        # Befehl zum Öffnen der CD
        mciSendString("open d: type cdaudio alias mycd", None, 0, None)
        # Befehl zum Öffnen des CD-Laufwerks
        mciSendString("set mycd door open", None, 0, None)
 
if __name__ == "__main__":
    main()

#include <bits/stdc++.h>
using namespace std;

// Movie class
class Movie
{
public:
    int id;
    string title;

    Movie(int id, string title) : id(id), title(title) {}
};

// Theater class
class Theater
{
public:
    int id;
    string name;
    vector<Movie *> movies;
    map<int, int> availableSeats;

    Theater(int id, string name) : id(id), name(name) {}

    // Add a movie to the theater
    void addMovie(Movie *movie, int seatCount)
    {
        movies.push_back(movie);
        availableSeats[movie->id] = seatCount;
    }

    // Display the list of movies playing in this theater
    void displayMovies()
    {
        cout << "Movies playing in theater: " << name << endl;
        for (auto &movie : movies)
        {
            cout << "Movie ID: " << movie->id << ", Title: " << movie->title << endl;
        }
    }

    // Check if seats are available
    bool hasAvailableSeats(Movie *movie)
    {
        return availableSeats[movie->id] > 0;
    }

    // Book a seat
    void bookSeat(Movie *movie)
    {
        if (hasAvailableSeats(movie))
        {
            availableSeats[movie->id]--;
            cout << "Booking successful! Seats remaining: " << availableSeats[movie->id] << endl;
        }
        else
        {
            cout << "No seats available!" << endl;
        }
    }
};

// BookingSystem class
class BookingSystem
{
public:
    vector<Theater *> theaters;

    // Add a theater to the system
    void addTheater(Theater *theater)
    {
        theaters.push_back(theater);
    }

    // Display all theaters
    void displayTheaters()
    {
        cout << "Available theaters:\n";
        for (auto &theater : theaters)
        {
            cout << "Theater ID: " << theater->id << ", Name: " << theater->name << endl;
        }
    }

    // View movies in a selected theater
    void viewMoviesInTheater(int theaterId)
    {
        for (auto &theater : theaters)
        {
            if (theater->id == theaterId)
            {
                theater->displayMovies();
                return;
            }
        }
        cout << "Theater not found!" << endl;
    }

    // Book tickets for a movie
    void bookTicket(int theaterId, int movieId)
    {
        for (auto &theater : theaters)
        {
            if (theater->id == theaterId)
            {
                for (auto &movie : theater->movies)
                {
                    if (movie->id == movieId)
                    {
                        if (theater->hasAvailableSeats(movie))
                        {
                            theater->bookSeat(movie);
                            return;
                        }
                        else
                        {
                            cout << "No seats available for this movie!" << endl;
                            return;
                        }
                    }
                }
                cout << "Movie not found in this theater!" << endl;
                return;
            }
        }
        cout << "Theater not found!" << endl;
    }
};

// Main function for demonstration
int main()
{
    BookingSystem system;

    // Create movies
    Movie *movie1 = new Movie(1, "Avengers");
    Movie *movie2 = new Movie(2, "Inception");

    // Create theaters and add movies
    Theater *theater1 = new Theater(1, "PVR Cinemas");
    Theater *theater2 = new Theater(2, "INOX");
    theater1->addMovie(movie1, 10);
    theater1->addMovie(movie2, 10);
    theater2->addMovie(movie2, 10);

    // Add theaters to booking system
    system.addTheater(theater1);
    system.addTheater(theater2);

    // Display theaters
    system.displayTheaters();

    // View movies in theater 1
    system.viewMoviesInTheater(1);

    // Book a ticket for Avengers in PVR Cinemas
    system.bookTicket(1, 1);

    // Attempt to book again
    system.bookTicket(1, 1);

    return 0;
}

# main.py

from fastapi import FastAPI
from routes.tasks import tasks_route

app = FastAPI()

app.include_router(tasks_route)

-------------------------

# routes > tasks.py

from fastapi import APIRouter

tasks_route = APIRouter()

@tasks_route.get('/tasks')
def get_tasks():
  return {'tasks': []}

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
from uuid import UUID, uuid4

class Task(BaseModel):
    id : UUID = Field(default_factory = uuid4)
    name : str
    description : str
    done: bool = False

tasks_db = []

def find_task(_id):
    for idx, task in enumerate(tasks_db):
        if task.id == _id:
            return idx, task

app = FastAPI()

@app.get('/')
def index():
    return {'msg': 'hello, world'}

# Add new task to database
@app.put('/add_task')
def add_task(task : Task):
    tasks_db.append(task)

    return {'msg': 'Task created', 'task': task}

# Get all tasks from database
@app.get('/tasks')
def get_tasks():
    return {'tasks': tasks_db}

# Get one task by id
@app.get('/task/{_id}')
def get_task(_id: UUID):
    task = find_task(_id)[1]
    if task:
        return {'task': task}
    
    
    return HTTPException(status_code = 404, detail = 'This task is not found :(')

# Update task by id
@app.put('/update_task/{_id}')
def update_task(_id : UUID, updatedtask : Task):
    task = find_task(_id)
    if task:
        task_idx = task[0]
        tasks_db[task_idx] = updatedtask
        return {'msg': 'Task updated', 'task': updatedtask}
    
    return HTTPException(status_code = 404, detail = 'This task is not found :(')

# Delete task
@app.delete('/delete_task/{_id}')
def delete_task(_id : UUID):
    task = find_task(_id)[1]
    tasks_db.remove(task)

    return {'msg': f'task {task.name} deleted ;)'}

#include <bits/stdc++.h>
#include <chrono>
#include <thread>
using namespace std;

class Payment
{
public:
    virtual double calculateCost(double hours) = 0;
};

class CarPayment : public Payment
{
public:
    double calculateCost(double hours) { return hours * 2; }
};

class BikePayment : public Payment
{
public:
    double calculateCost(double hours) { return hours * 1; }
};

class Vehicle
{
protected:
    Payment *payment;
    chrono::time_point<chrono::system_clock> parkedTime;

public:
    virtual string getType() = 0;
    virtual double calculateCost(double hours)
    {
        return payment->calculateCost(hours);
    }

    void setParkedTime()
    {
        parkedTime = chrono::system_clock::now();
    }

    chrono::time_point<chrono::system_clock> getParkedTime()
    {
        return parkedTime;
    }
};

class Car : public Vehicle
{
public:
    Car() { payment = new CarPayment(); }
    string getType() { return "Car"; }
};

class Bike : public Vehicle
{
public:
    Bike() { payment = new BikePayment(); }
    string getType() { return "Bike"; }
};

class ParkingLot
{
private:
    vector<vector<vector<Vehicle *>>> spots;
    int floors;
    int rows;
    int spotsPerRow;

public:
    ParkingLot(int floors, int rows, int spotsPerRow)
    {
        this->floors = floors;
        this->rows = rows;
        this->spotsPerRow = spotsPerRow;
        spots.resize(floors);
        for (int i = 0; i < floors; i++)
        {
            spots[i].resize(rows);
            for (int j = 0; j < rows; j++)
            {
                spots[i][j].resize(spotsPerRow);
            }
        }
    }

    bool park(Vehicle *v, int floor, int row, int spot)
    {
        if (spots[floor][row][spot] == nullptr)
        {
            spots[floor][row][spot] = v;
            cout << v->getType() << " parked successfully at floor " << floor << ", row " << row << ", spot " << spot << "." << endl;
            return true;
        }
        else
        {
            cout << "Spot already occupied." << endl;
            return false;
        }
    }

    bool leave(Vehicle *v)
    {
        for (int i = 0; i < floors; i++)
        {
            for (int j = 0; j < rows; j++)
            {
                for (int k = 0; k < spotsPerRow; k++)
                {
                    if (spots[i][j][k] == v)
                    {
                        double hours = calculateHoursParked(spots[i][j][k]);
                        double cost = spots[i][j][k]->calculateCost(hours);
                        spots[i][j][k] = nullptr;
                        cout << v->getType() << " left successfully. Total cost: " << cost << " " << hours * 1e8 << endl;
                        return true;
                    }
                }
            }
        }
        cout << v->getType() << " not found." << endl;
        return false;
    }

    int availableSpots(int floor)
    {
        int count = 0;
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < spotsPerRow; j++)
            {
                if (spots[floor][i][j] == nullptr)
                {
                    count++;
                }
            }
        }
        return count;
    }

    double calculateHoursParked(Vehicle *v)
    {
        for (int i = 0; i < floors; i++)
        {
            for (int j = 0; j < rows; j++)
            {
                for (int k = 0; k < spotsPerRow; k++)
                {
                    if (spots[i][j][k] == v)
                    {
                        // get the current time
                        auto now = chrono::system_clock::now();
                        // get the time the vehicle was parked
                        auto parkedTime = spots[i][j][k]->getParkedTime();
                        // calculate the difference in hours
                        chrono::duration<double> duration = now - parkedTime; // Difference in seconds
                        double hours = duration.count() / 3600;               // Convert seconds to hours
                        return hours;
                    }
                }
            }
        }
        return 0;
    }
};

int main()
{
    ParkingLot lot(3, 10, 20);
    Car car1, car2;
    Bike bike1, bike2;

    car1.setParkedTime();
    lot.park(&car1, 0, 0, 0);
    car2.setParkedTime();
    lot.park(&car2, 0, 0, 1);
    bike1.setParkedTime();
    lot.park(&bike1, 0, 0, 2);

    cout << "Available spots on floor 0: " << lot.availableSpots(0) << endl;
    _sleep(500);
    lot.leave(&car1);
    lot.leave(&bike2);

    cout << "Available spots on floor 0: " << lot.availableSpots(0) << endl;

    return 0;
}

struct Queue {
    stack<int> s1, s2;
 
    // Enqueue an item to the queue
    void enQueue(int x)
    {
        // Push item into the first stack
        s1.push(x);
    }
 
    // Dequeue an item from the queue
    int deQueue()
    {
        // if both stacks are empty
        if (s1.empty() && s2.empty()) {
            return -1;
        }
 
        // if s2 is empty, move
        // elements from s1
        if (s2.empty()) {
            while (!s1.empty()) {
                s2.push(s1.top());
                s1.pop();
            }
        }
 
        // return the top item from s2
        int x = s2.top();
        s2.pop();
        return x;
    }
};

struct Queue {
    stack<int> s;
 
    // Enqueue an item to the queue
    void enQueue(int x)
    {
        s.push(x);
    }
 
    // Dequeue an item from the queue
    int deQueue()
    {
        if (s.empty()) {
            return -1;
        }
 
        // pop an item from the stack
        int x = s.top();
        s.pop();
 
        // if stack becomes empty, return
        // the popped item
        if (s.empty())
            return x;
 
        // recursive call
        int item = deQueue();
 
        // push popped item back to the stack
        s.push(x);
 
        // return the result of deQueue() call
        return item;
    }
};

class TwoStacks
{
    vector<int> elements;
    int ptr1, ptr2, capacity;

    TwoStacks(int capacity)
    {
        for(int i=0; i < capacity; i++)
        {
            elements.push_back(-1);
        }
        ptr1 = 0;
        ptr2 = capacity-1;
        this->capacity = capacity;
    }

    bool push1(int value)
    {
        if(ptr1 <= ptr2)
        {
            elements[ptr1] = value;
            ptr1++;
        }
        else 
        {
            return false;
        }
    }

    bool push2(int value)
    {
        if(ptr1 <= ptr2)
        {
            elements[ptr2] = value;
            ptr2--;
        }
        else 
        {
            return false;
        }
    }

    int pop1()
    {
        if(ptr1-1 < 0)
        {
            return -1;
        }
        ptr1--;
        return elements[ptr1];
    }

    int pop2()
    {
        if(ptr2+1 >= capacity)
        {
            return -1;
        }
        ptr2++;
        return elements[ptr2];
    }    

};

.layout-center {
  margin: 0 auto;
}
/* common css */
.overflow-hidden {
  overflow: hidden;
}
.section-container {
  width: 1256px;
  margin: 0 auto;
}
.section-vertical-margin {
  margin-top: 128px;
  margin-bottom: 128px;
}
.display-desktop-device--how-it-work {
  display: block;
}
.display-tab-device--how-it-work {
  display: none;
}
.display-mobile-device--how-it-work {
  display: none;
}
.relative {
  position: relative;
}
.absolute {
  position: absolute;
}
.h-400px {
  height: 400px;
}
.h-193px {
  height: 193px;
}
.it-works-left-one img {
  height: 100%;
}
.it-works-left-two img {
  height: 100%;
}
.it-works-right-one img {
  height: 100%;
}
.it-works-right-two img {
  height: 100%;
}
.how-it-work--header {
  color: #021a15;
  font-family: "din-black";
  font-size: 64px;
  font-style: normal;
  font-weight: 900;
  line-height: 120%;
  margin-bottom: 40px;
  text-transform: uppercase;
}
.it-work-card-text--black {
  color: #021a15;
  font-family: "din-black";
  font-size: 40px;
  font-style: normal;
  font-weight: 900;
  margin-bottom: 0px;
  line-height: normal;
  bottom: 20px;
  left: 20px;
  right: 20px;
}
.it-work-card-text--white {
  color: #fff;
  font-family: "din-black";
  font-size: 40px;
  font-style: normal;
  font-weight: 900;
  margin-bottom: 0px;
  line-height: normal;
  bottom: 20px;
  left: 20px;
  right: 20px;
}
.it-work-card-text--green {
  font-family: "din-black";
  font-size: 40px;
  font-style: normal;
  font-weight: 900;
  margin-bottom: 0px;
  line-height: normal;
  top: 20px;
  left: 20px;
  right: 20px;
}
@media only screen and (min-width: 1024px) and (max-width: 1439px) {
  .banner-text {
    position: absolute;
    left: 12%;
    right: 12%;
    bottom: 20px;
    color: #b4ee26;
    /* font-family: "DIN"; */
    font-size: 64px;
    font-style: normal;
    font-weight: 900;
    text-transform: uppercase;
  }
  .section-container {
    width: calc(100%) !important;
    padding: 0 50px;
  }
  .section-vertical-margin {
    margin-top: 128px;
    margin-bottom: 128px;
  }
}
@media only screen and (min-width: 769px) and (max-width: 1023px) {
  .banner-text {
    position: absolute;
    bottom: 10px;
    color: #b4ee26;
    font-family: "DIN";
    font-size: 44px;
    font-style: normal;
    font-weight: 900;
    text-transform: uppercase;
  }
  .section-container {
    width: calc(100%) !important;
    padding: 0 50px;
  }
  .section-vertical-margin {
    margin-top: 128px;
    margin-bottom: 128px;
  }
}
@media only screen and (min-width: 481px) and (max-width: 768px) {
  .section-container {
    width: calc(100%) !important;
    padding: 0 50px;
  }
  .section-vertical-margin {
    margin-top: 40px;
    margin-bottom: 80px;
  }

  .display-desktop-device--how-it-work {
    display: none;
  }
  .display-tab-device--how-it-work {
    display: block;
  }
  .display-mobile-device--how-it-work {
    display: none;
  }
  .section-container {
    width: calc(100% - 30px) !important;
    margin: 0, 15px;
  }
  .section-vertical-margin {
    margin-top: 40px;
    margin-bottom: 80px;
  }
  .flex-col {
    flex-direction: column;
  }
  .how-it-work--header {
    color: #021a15;
    font-family: "din-black";
    font-size: 40px;
    font-style: normal;
    font-weight: 900;
    line-height: 120%;
    margin-bottom: 30px;
    text-transform: uppercase;
  }
  .it-work-card-text--black {
    color: #021a15;
    font-family: "din-black";
    font-size: 26px;
    font-style: normal;
    font-weight: 900;
    margin-bottom: 0px;
    line-height: normal;
    bottom: 20px;
    left: 20px;
    right: 20px;
  }
  .it-work-card-text--white {
    color: #fff;
    font-family: "din-black";
    font-size: 26px;
    font-style: normal;
    font-weight: 900;
    margin-bottom: 0px;
    line-height: normal;
    bottom: 20px;
    left: 20px;
    right: 20px;
  }
  .it-work-card-text--green {
    font-family: "din-black";
    font-size: 26px;
    font-style: normal;
    font-weight: 900;
    margin-bottom: 0px;
    line-height: normal;
    top: 20px;
    left: 20px;
    right: 20px;
  }
}
@media only screen and (max-width: 481px) {
  /* section container */
  .section-container {
    width: calc(100%) !important;
    padding: 0 15px;
  }
  .section-vertical-margin {
    margin-top: 40px;
    margin-bottom: 80px;
  }
  .display-desktop-device--how-it-work {
    display: none;
  }
  .display-tab-device--how-it-work {
    display: none;
  }
  .display-mobile-device--how-it-work {
    display: block;
  }
  .flex-col {
    flex-direction: column;
  }
  .home-page-banner-btn-wrapper {
    display: flex;
    background-color: #021a15;
  }
  .how-it-work--header {
    color: #021a15;
    font-family: "din-black";
    font-size: 32px;
    font-style: normal;
    font-weight: 900;
    line-height: 120%;
    margin-bottom: 30px;
    text-transform: uppercase;
  }
  .it-work-card-text--black {
    color: #021a15;
    font-family: "din-black";
    font-size: 26px;
    font-style: normal;
    font-weight: 900;
    margin-bottom: 0px;
    line-height: normal;
    bottom: 20px;
    left: 20px;
    right: 20px;
  }
  .it-work-card-text--white {
    color: #fff;
    font-family: "din-black";
    font-size: 26px;
    font-style: normal;
    font-weight: 900;
    margin-bottom: 0px;
    line-height: normal;
    bottom: 20px;
    left: 20px;
    right: 20px;
  }
  .it-work-card-text--green {
    font-family: "din-black";
    font-size: 26px;
    font-style: normal;
    font-weight: 900;
    margin-bottom: 0px;
    line-height: normal;
    top: 20px;
    left: 20px;
    right: 20px;
  }
}

class DLL
{
public:
    DLL *next;
    DLL *prev;
    int _value;
    int _key;

    DLL(int _key, int _value)
    {
        this->_key = _key;
        this->_value = _value;
        next = NULL;
        prev = NULL;
    }
};

class LRU
{
public:
    DLL *head;
    DLL *tail;
    int capacity;
    map<int, DLL *> location;

    LRU(int capacity)
    {
        this->capacity = capacity;
        head = new DLL(-1, -1);
        tail = new DLL(-1, -1);
        head->next = tail;
        tail->prev = head;
    }

    void deleteNode(int key)
    {
        DLL *cur = location[key];
        DLL *prev_node = cur->prev;
        DLL *next_node = cur->next;

        prev_node->next = next_node;
        next_node->prev = prev_node;
        location.erase(key);
    }

    void addNode(int key, int value)
    {
        DLL *new_node = new DLL(key, value);
        DLL *next_node = head->next;

        head->next = new_node;
        new_node->prev = head;
        new_node->next = next_node;
        next_node->prev = new_node;
        location[key] = new_node;
    }

    void putInCache(int key, int value)
    {
        // value is not already in cache
        if (location.find(key) == location.end())
        {
            addNode(key, value);
            if (location.size() > capacity)
            {
                deleteNode(tail->prev->_key);
            }
        }
        else
        {
            deleteNode(key);
            addNode(key, value);
        }
    }

    int getData(int key)
    {
        if (location.find(key) != location.end())
        {
            int val = location[key]->_value;
            deleteNode(key);
            addNode(key, val);
            return val;
        }
        return -1;
    }
};

import pendulum

items = [
    {'name': 'Milk', 'expire_date': '2024-09-15'},
    {'name': 'Bread', 'expire_date': '2024-09-18'},
    {'name': 'Yogurt', 'expire_date': '2024-09-25'},
]

def check_expire_date(items):
    for item in items:
        expire_date = pendulum.parse(item.get('expire_date'))
        cuurent_date = pendulum.now()

        if expire_date <= cuurent_date:
            print(f' {item.get('name')} expired')


check_expire_date(items=items)

<script type="javascript">
    // JS related code goes here
</script>
<noscript>
    <a href="next_page.html?noJS=true">JavaScript is disabled on the page. Enable it asap!</a>
</noscript>

{
	"blocks": [
		{
			"type": "header",
			"text": {
				"type": "plain_text",
				"text": ":star: Xero Boost Days! :star:"
			}
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "Please see below for what's on this week! "
			}
		},
		{
			"type": "divider"
		},
		{
			"type": "header",
			"text": {
				"type": "plain_text",
				"text": ":calendar-date-16: Monday, 16th September",
				"emoji": true
			}
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "\n:coffee: *Café Partnership*: Enjoy free coffee and café-style beverages from our Cafe partner *Edwards*.\n:Lunch: *Lunch*: from *12pm* in the kitchen.\n:massage:*Wellbeing*: Pilates at *SP Brisbane City* is bookable every Monday! Watch this channel on how to book."
			}
		},
		{
			"type": "header",
			"text": {
				"type": "plain_text",
				"text": ":calendar-date-17: Wednesday,17th September",
				"emoji": true
			}
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": ":coffee: *Café Partnership*: Enjoy free coffee and café-style beverages from our Cafe partner *Edwards*.\n:footprint: *Steptember Morning Tea*:from *10am* in the kitchen. Followed by a 30 minute walk around the city!"
			}
		},
		{
			"type": "divider"
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "*LATER THIS MONTH:*"
			}
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "*Wednesday, 25th September*\n :blob-party: *Social +*: Drinks, food, and engaging activities bringing everyone together."
			}
		},
		{
			"type": "divider"
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "Stay tuned to this channel for more details, check out the <https://calendar.google.com/calendar/u/0?cid=Y19uY2M4cDN1NDRsdTdhczE0MDhvYjZhNnRjb0Bncm91cC5jYWxlbmRhci5nb29nbGUuY29t|*Brisbane Social Calendar*>, and get ready to Boost your workdays!\n\nLove,\nWX Team :party-wx:"
			}
		}
	]
}

{
	"blocks": [
		{
			"type": "header",
			"text": {
				"type": "plain_text",
				"text": ":star: Xero Boost Days! :star:"
			}
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "Please see below for what's on this week! "
			}
		},
		{
			"type": "divider"
		},
		{
			"type": "header",
			"text": {
				"type": "plain_text",
				"text": ":calendar-date-18: Wednesday, 18th September",
				"emoji": true
			}
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "\n:coffee: *Café Partnership*: Café Partnership: Enjoy free coffee and café-style beverages from our partner, *Elixir Sabour*, which used to be called Hungry Bean.\n:breakfast: *Lunch*: Provided by *Elixir Sabour* from *12pm* in the All Hands.\n:massage:*Wellbeing*: Crossfit class at *Be Athletic* from 11am."
			}
		},
		{
			"type": "header",
			"text": {
				"type": "plain_text",
				"text": ":calendar-date-19: Thursday, 19th September",
				"emoji": true
			}
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": ":coffee: *Café Partnership*: Café Partnership: Enjoy coffee and café-style beverages from our partner, *Elixir Sabour*, which used to be called Hungry Bean.\n:footprint: * Steptember Morning Tea*: Provided by *Elixir Sabour* from *10am* in the All Hands, followed by a 30 minute walk around the city."
			}
		},
		{
			"type": "divider"
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "*Social This Week: 45 Clarence St Turns 1!*"
			}
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "*Thursday, 19th September *\n :blob-party: *Social +*: Drinks, food, and engaging activities bringing everyone together."
			}
		},
		{
			"type": "divider"
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "Stay tuned to this channel for more details, check out the <https://calendar.google.com/calendar/u/0/r?cid=Y185aW90ZWV0cXBiMGZwMnJ0YmtrOXM2cGFiZ0Bncm91cC5jYWxlbmRhci5nb29nbGUuY29t|*Sydney Social Calendar*>, and get ready to Boost your workdays!\n\nLove,\nWX Team :party-wx:"
			}
		}
	]
}

#include <bits/stdc++.h>

using namespace std;

class Piece
{
private:
    virtual bool AreSquaresLegal(int srcRow, int srcCol, int destRow, int destCol, Piece *GameBoard[8][8]) = 0;
    char mPieceColor;

public:
    Piece(char PieceColor) : mPieceColor(PieceColor) {}
    ~Piece() {}
    virtual char GetPiece() = 0;
    char GetColor()
    {
        return mPieceColor;
    }
    bool IsLegalMove(int srcRow, int srcCol, int destRow, int destCol, Piece *GameBoard[8][8])
    {
        Piece *destPiece = GameBoard[destRow][destCol];
        if ((destPiece == 0) || (mPieceColor != destPiece->GetColor()))
        {
            return AreSquaresLegal(srcRow, srcCol, destRow, destCol, GameBoard);
        }
        return false;
    }
};



class PawnPiece : public Piece
{
public:
    PawnPiece(char PieceColor) : Piece(PieceColor) {}
    ~PawnPiece() {}

private:
    virtual char GetPiece()
    {
        return 'P';
    }
    bool AreSquaresLegal(int srcRow, int srcCol, int destRow, int destCol, Piece *GameBoard[8][8])
    {
        Piece *destPiece = GameBoard[destRow][destCol];
        if (destPiece == 0)
        {
            // Destination square is unoccupied
            if (srcCol == destCol)
            {
                if (GetColor() == 'W')
                {
                    if (destRow == srcRow + 1)
                    {
                        return true;
                    }
                }
                else
                {
                    if (destRow == srcRow - 1)
                    {
                        return true;
                    }
                }
            }
        }
        else
        {
            // Dest holds piece of opposite color
            if ((srcCol == destCol + 1) || (srcCol == destCol - 1))
            {
                if (GetColor() == 'W')
                {
                    if (destRow == srcRow + 1)
                    {
                        return true;
                    }
                }
                else
                {
                    if (destRow == srcRow - 1)
                    {
                        return true;
                    }
                }
            }
        }
        return false;
    }
};



class KnightPiece : public Piece
{
public:
    KnightPiece(char PieceColor) : Piece(PieceColor) {}
    ~KnightPiece() {}

private:
    virtual char GetPiece()
    {
        return 'N';
    }
    bool AreSquaresLegal(int srcRow, int srcCol, int destRow, int destCol, Piece *GameBoard[8][8])
    {
        // Destination square is unoccupied or occupied by opposite color
        if ((srcCol == destCol + 1) || (srcCol == destCol - 1))
        {
            if ((srcRow == destRow + 2) || (srcRow == destRow - 2))
            {
                return true;
            }
        }
        if ((srcCol == destCol + 2) || (srcCol == destCol - 2))
        {
            if ((srcRow == destRow + 1) || (srcRow == destRow - 1))
            {
                return true;
            }
        }
        return false;
    }
};



class BishopPiece : public Piece
{
public:
    BishopPiece(char PieceColor) : Piece(PieceColor) {}
    ~BishopPiece() {}

private:
    virtual char GetPiece()
    {
        return 'B';
    }
    bool AreSquaresLegal(int srcRow, int srcCol, int destRow, int destCol, Piece *GameBoard[8][8])
    {
        if ((destCol - srcCol == destRow - srcRow) || (destCol - srcCol == srcRow - destRow))
        {
            // Make sure that all invervening squares are empty
            int iRowOffset = (destRow - srcRow > 0) ? 1 : -1;
            int iColOffset = (destCol - srcCol > 0) ? 1 : -1;
            int iCheckRow;
            int iCheckCol;
            for (iCheckRow = srcRow + iRowOffset, iCheckCol = srcCol + iColOffset;
                 iCheckRow != destRow;
                 iCheckRow = iCheckRow + iRowOffset, iCheckCol = iCheckCol + iColOffset)
            {
                if (GameBoard[iCheckRow][iCheckCol] != 0)
                {
                    return false;
                }
            }
            return true;
        }
        return false;
    }
};



class RookPiece : public Piece
{
public:
    RookPiece(char PieceColor) : Piece(PieceColor) {}
    ~RookPiece() {}

private:
    virtual char GetPiece()
    {
        return 'R';
    }
    bool AreSquaresLegal(int srcRow, int srcCol, int destRow, int destCol, Piece *GameBoard[8][8])
    {
        if (srcRow == destRow)
        {
            // Make sure that all invervening squares are empty
            int iColOffset = (destCol - srcCol > 0) ? 1 : -1;
            for (int iCheckCol = srcCol + iColOffset; iCheckCol != destCol; iCheckCol = iCheckCol + iColOffset)
            {
                if (GameBoard[srcRow][iCheckCol] != 0)
                {
                    return false;
                }
            }
            return true;
        }
        else if (destCol == srcCol)
        {
            // Make sure that all invervening squares are empty
            int iRowOffset = (destRow - srcRow > 0) ? 1 : -1;
            for (int iCheckRow = srcRow + iRowOffset; iCheckRow != destRow; iCheckRow = iCheckRow + iRowOffset)
            {
                if (GameBoard[iCheckRow][srcCol] != 0)
                {
                    return false;
                }
            }
            return true;
        }
        return false;
    }
};



class QueenPiece : public Piece
{
public:
    QueenPiece(char PieceColor) : Piece(PieceColor) {}
    ~QueenPiece() {}

private:
    virtual char GetPiece()
    {
        return 'Q';
    }
    bool AreSquaresLegal(int srcRow, int srcCol, int destRow, int destCol, Piece *GameBoard[8][8])
    {
        if (srcRow == destRow)
        {
            // Make sure that all invervening squares are empty
            int iColOffset = (destCol - srcCol > 0) ? 1 : -1;
            for (int iCheckCol = srcCol + iColOffset; iCheckCol != destCol; iCheckCol = iCheckCol + iColOffset)
            {
                if (GameBoard[srcRow][iCheckCol] != 0)
                {
                    return false;
                }
            }
            return true;
        }
        else if (destCol == srcCol)
        {
            // Make sure that all invervening squares are empty
            int iRowOffset = (destRow - srcRow > 0) ? 1 : -1;
            for (int iCheckRow = srcRow + iRowOffset; iCheckRow != destRow; iCheckRow = iCheckRow + iRowOffset)
            {
                if (GameBoard[iCheckRow][srcCol] != 0)
                {
                    return false;
                }
            }
            return true;
        }
        else if ((destCol - srcCol == destRow - srcRow) || (destCol - srcCol == srcRow - destRow))
        {
            // Make sure that all invervening squares are empty
            int iRowOffset = (destRow - srcRow > 0) ? 1 : -1;
            int iColOffset = (destCol - srcCol > 0) ? 1 : -1;
            int iCheckRow;
            int iCheckCol;
            for (iCheckRow = srcRow + iRowOffset, iCheckCol = srcCol + iColOffset;
                 iCheckRow != destRow;
                 iCheckRow = iCheckRow + iRowOffset, iCheckCol = iCheckCol + iColOffset)
            {
                if (GameBoard[iCheckRow][iCheckCol] != 0)
                {
                    return false;
                }
            }
            return true;
        }
        return false;
    }
};



class KingPiece : public Piece
{
public:
    KingPiece(char PieceColor) : Piece(PieceColor) {}
    ~KingPiece() {}

private:
    virtual char GetPiece()
    {
        return 'K';
    }
    bool AreSquaresLegal(int srcRow, int srcCol, int destRow, int destCol, Piece *GameBoard[8][8])
    {
        int iRowDelta = destRow - srcRow;
        int iColDelta = destCol - srcCol;
        if (((iRowDelta >= -1) && (iRowDelta <= 1)) &&
            ((iColDelta >= -1) && (iColDelta <= 1)))
        {
            return true;
        }
        return false;
    }
};



class ChessBoard
{
public:
    Piece *MainGameBoard[8][8];
    ChessBoard()
    {
        for (int iRow = 0; iRow < 8; ++iRow)
        {
            for (int iCol = 0; iCol < 8; ++iCol)
            {
                MainGameBoard[iRow][iCol] = 0;
            }
        }
        // Allocate and place black pieces
        for (int iCol = 0; iCol < 8; ++iCol)
        {
            MainGameBoard[6][iCol] = new PawnPiece('B');
        }
        MainGameBoard[7][0] = new RookPiece('B');
        MainGameBoard[7][1] = new KnightPiece('B');
        MainGameBoard[7][2] = new BishopPiece('B');
        MainGameBoard[7][3] = new KingPiece('B');
        MainGameBoard[7][4] = new QueenPiece('B');
        MainGameBoard[7][5] = new BishopPiece('B');
        MainGameBoard[7][6] = new KnightPiece('B');
        MainGameBoard[7][7] = new RookPiece('B');
        // Allocate and place white pieces
        for (int iCol = 0; iCol < 8; ++iCol)
        {
            MainGameBoard[1][iCol] = new PawnPiece('W');
        }
        MainGameBoard[0][0] = new RookPiece('W');
        MainGameBoard[0][1] = new KnightPiece('W');
        MainGameBoard[0][2] = new BishopPiece('W');
        MainGameBoard[0][3] = new KingPiece('W');
        MainGameBoard[0][4] = new QueenPiece('W');
        MainGameBoard[0][5] = new BishopPiece('W');
        MainGameBoard[0][6] = new KnightPiece('W');
        MainGameBoard[0][7] = new RookPiece('W');
    }
    ~ChessBoard()
    {
        for (int iRow = 0; iRow < 8; ++iRow)
        {
            for (int iCol = 0; iCol < 8; ++iCol)
            {
                delete MainGameBoard[iRow][iCol];
                MainGameBoard[iRow][iCol] = 0;
            }
        }
    }

    void Print()
    {
        const int kiSquareWidth = 4;
        const int kiSquareHeight = 3;
        for (int iRow = 0; iRow < 8 * kiSquareHeight; ++iRow)
        {
            int iSquareRow = iRow / kiSquareHeight;
            // Print side border with numbering
            if (iRow % 3 == 1)
            {
                cout << '-' << (char)('1' + 7 - iSquareRow) << '-';
            }
            else
            {
                cout << "---";
            }
            // Print the chess board
            for (int iCol = 0; iCol < 8 * kiSquareWidth; ++iCol)
            {
                int iSquareCol = iCol / kiSquareWidth;
                if (((iRow % 3) == 1) && ((iCol % 4) == 1 || (iCol % 4) == 2) && MainGameBoard[7 - iSquareRow][iSquareCol] != 0)
                {
                    if ((iCol % 4) == 1)
                    {
                        cout << MainGameBoard[7 - iSquareRow][iSquareCol]->GetColor();
                    }
                    else
                    {
                        cout << MainGameBoard[7 - iSquareRow][iSquareCol]->GetPiece();
                    }
                }
                else
                {
                    if ((iSquareRow + iSquareCol) % 2 == 1)
                    {
                        cout << '*';
                    }
                    else
                    {
                        cout << ' ';
                    }
                }
            }
            cout << endl;
        }
        // Print the bottom border with numbers
        for (int iRow = 0; iRow < kiSquareHeight; ++iRow)
        {
            if (iRow % 3 == 1)
            {
                cout << "---";
                for (int iCol = 0; iCol < 8 * kiSquareWidth; ++iCol)
                {
                    int iSquareCol = iCol / kiSquareWidth;
                    if ((iCol % 4) == 1)
                    {
                        cout << (iSquareCol + 1);
                    }
                    else
                    {
                        cout << '-';
                    }
                }
                cout << endl;
            }
            else
            {
                for (int iCol = 1; iCol < 9 * kiSquareWidth; ++iCol)
                {
                    cout << '-';
                }
                cout << endl;
            }
        }
    }

    bool IsInCheck(char PieceColor)
    {
        // Find the king
        int iKingRow;
        int iKingCol;
        for (int iRow = 0; iRow < 8; ++iRow)
        {
            for (int iCol = 0; iCol < 8; ++iCol)
            {
                if (MainGameBoard[iRow][iCol] != 0)
                {
                    if (MainGameBoard[iRow][iCol]->GetColor() == PieceColor)
                    {
                        if (MainGameBoard[iRow][iCol]->GetPiece() == 'K')
                        {
                            iKingRow = iRow;
                            iKingCol = iCol;
                        }
                    }
                }
            }
        }
        // Run through the opponent's pieces and see if any can take the king
        for (int iRow = 0; iRow < 8; ++iRow)
        {
            for (int iCol = 0; iCol < 8; ++iCol)
            {
                if (MainGameBoard[iRow][iCol] != 0)
                {
                    if (MainGameBoard[iRow][iCol]->GetColor() != PieceColor)
                    {
                        if (MainGameBoard[iRow][iCol]->IsLegalMove(iRow, iCol, iKingRow, iKingCol, MainGameBoard))
                        {
                            return true;
                        }
                    }
                }
            }
        }

        return false;
    }

    bool CanMove(char PieceColor)
    {
        // Run through all pieces
        for (int iRow = 0; iRow < 8; ++iRow)
        {
            for (int iCol = 0; iCol < 8; ++iCol)
            {
                if (MainGameBoard[iRow][iCol] != 0)
                {
                    // If it is a piece of the current player, see if it has a legal move
                    if (MainGameBoard[iRow][iCol]->GetColor() == PieceColor)
                    {
                        for (int iMoveRow = 0; iMoveRow < 8; ++iMoveRow)
                        {
                            for (int iMoveCol = 0; iMoveCol < 8; ++iMoveCol)
                            {
                                if (MainGameBoard[iRow][iCol]->IsLegalMove(iRow, iCol, iMoveRow, iMoveCol, MainGameBoard))
                                {
                                    // Make move and check whether king is in check
                                    Piece *tempPiece = MainGameBoard[iMoveRow][iMoveCol];
                                    MainGameBoard[iMoveRow][iMoveCol] = MainGameBoard[iRow][iCol];
                                    MainGameBoard[iRow][iCol] = 0;
                                    bool moreMoves = !IsInCheck(PieceColor);
                                    // Undo the move
                                    MainGameBoard[iRow][iCol] = MainGameBoard[iMoveRow][iMoveCol];
                                    MainGameBoard[iMoveRow][iMoveCol] = tempPiece;
                                    if (moreMoves)
                                    {
                                        return true;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        return false;
    }
};



class Game
{
private:
    ChessBoard board;
    char currentPlayer;

public:
    Game() : currentPlayer('W') {}
    ~Game() {}

    void Start()
    {
        do
        {
            GetNextMove(board.MainGameBoard);
            changeTurn();
        } while (!IsGameOver());
        board.Print();
    }

    void GetNextMove(Piece *GameBoard[8][8])
    {
        bool isValidMove = false;
        do
        {
            system("clear");
            board.Print();

            // Get input and convert to coordinates
            cout << currentPlayer << "'s Move: ";
            int startMove;
            cin >> startMove;
            int startRow = (startMove / 10) - 1;
            int startCol = (startMove % 10) - 1;

            cout << "To: ";
            int endMove;
            cin >> endMove;
            int iEndRow = (endMove / 10) - 1;
            int iEndCol = (endMove % 10) - 1;

            // Check that the indices are in range
            // and that the source and destination are different
            if ((startRow >= 0 && startRow <= 7) &&
                (startCol >= 0 && startCol <= 7) &&
                (iEndRow >= 0 && iEndRow <= 7) &&
                (iEndCol >= 0 && iEndCol <= 7))
            {
                // Additional checks in here
                Piece *currentPiece = GameBoard[startRow][startCol];
                // Check that the piece is the correct color
                if ((currentPiece != nullptr) && (currentPiece->GetColor() == currentPlayer))
                {
                    // Check that the destination is a valid destination
                    if (currentPiece->IsLegalMove(startRow, startCol, iEndRow, iEndCol, GameBoard))
                    {
                        // Make the move
                        Piece *tempPiece = GameBoard[iEndRow][iEndCol];
                        GameBoard[iEndRow][iEndCol] = GameBoard[startRow][startCol];
                        GameBoard[startRow][startCol] = 0;
                        // Make sure that the current player is not in check
                        if (!board.IsInCheck(currentPlayer))
                        {
                            delete tempPiece;
                            isValidMove = true;
                        }
                        else
                        { // Undo the last move
                            GameBoard[startRow][startCol] = GameBoard[iEndRow][iEndCol];
                            GameBoard[iEndRow][iEndCol] = tempPiece;
                        }
                    }
                }
            }
            if (!isValidMove)
            {
                cout << "Invalid Move!" << endl;
            }
        } while (!isValidMove);
    }

    void changeTurn()
    {
        currentPlayer = (currentPlayer == 'W') ? 'B' : 'W';
    }

    bool IsGameOver()
    {
        // Check that the current player can move
        // If not, we have a stalemate or checkmate
        bool moreMoves(false);
        moreMoves = board.CanMove(currentPlayer);
        if (!moreMoves)
        {
            if (board.IsInCheck(currentPlayer))
            {
                changeTurn();
                std::cout << "Checkmate, " << currentPlayer << " Wins!" << std::endl;
            }
            else
            {
                std::cout << "Draw!" << std::endl;
            }
        }
        return !moreMoves;
    }
};

int main()
{
    Game game;
    game.Start();
    return 0;
}

hi

mc