[ExtensionOf(classStr(SrsPrintDestinationTokensNone))] 
final class SrsPrintDestinationTokensNone_DC_Extension 
{ ///
	expandEmailToken(SrsPrintDestinationToken _token, SRSPrintDestinationSettings _settings) 
	{ 
	boolean mustSkipNext = true; 
	str tokenNotFoundMsg; 
// Skip the next by using the following trick with the try-catch block. 
//The base expandEmailToken() method generates a warning message that causes 
// problems if infolog contains some old warnings or error messages. 

	try 
	{ 
		if (mustSkipNext) 
		{ 
	// When an exception is thrown inside a ttsBegin-ttsCommit transaction block, no catch statement inside that transaction block can process the exception, 
	// unless it is a UpdateConflict or a DuplicateKeyException. We always want to be sure that the catch block is executed, 
	//so we use the UpdateConflict exception. 
	
		throw Exception::UpdateConflict; 
		} 
		tokenNotFoundMsg = next expandEmailToken(_token, _settings); 
	} 
	catch (Exception::UpdateConflict) 
	{ 
	// Don't expand the token, and don't show the error. Let Docentric report DSP class to deal with this. 
		tokenNotFoundMsg = DocConstantPlaceholder::PlaceholderStartSymbol + _token + DocConstantPlaceholder::PlaceholderEndSymbol; 
	} 
	return tokenNotFoundMsg; 
	} 
}

// Author : Khadiza Sultana 
#include<iostream>
 using namespace std;
  int binTodec(int binNum){
    int ans = 0, pow = 1;
    while(binNum > 0){
        int rem = binNum % 10; // accessing the last digit
        ans += rem * pow;
        binNum /= 10; // removing the last digit
        pow *= 2;
    }
    return ans;
  }

  int main(){
    int binNum;
    cin >> binNum;
    cout << binTodec(binNum) << endl;
    return 0;
  }

https://paragchapre.com/how-to-get-workers-current-position-department-and-manger-in-x/

HcmWorkerRecId   hcmWorkerRecId =  HcmWorker::userId2Worker(curUserId());

HcmPositionRecId hcmPositionRecId = HcmWorkerHelper::getPrimaryPosition(hcmWorkerRecId);


The code to get current worker manager.

HcmWorker currentWorker = HcmWorker::find(HcmWorkerLookup::currentWorker());
HcmWorker currentWorkerManager = HcmWorkerHelper::getManagerForWorker(currentWorker.RecId);


The code to get current worker department.

HcmWorker currentWorker = HcmWorker::find(HcmWorkerLookup::currentWorker());
OMOperatingUnit department = HcmWorkerHelper::getPrimaryDepartment(currentWorker.RecId);


The code to get current worker legal entity.

HcmWorker currentWorker = HcmWorker::find(HcmWorkerLookup::currentWorker());
CompanyInfo legalEntity = HcmWorkerHelper::getLegalEntity(currentWorker.RecId);

/////////************** GRAPHS IN C++ **********////////////////

/// graphs are combination of nodes and edges 
// nodes = entity in which data is stored
// edges = connecting line which connect the nodes 
// degree = no of edges connected



////// types of graphs

// undirected graph = arrow will not be provided ... (v---u == u--v)

// directed graph = arrow will  be provided ... (v---u != u--v)

// they're two type of degree in directed 
// indegree = edges coming inside  my way  
// outdegree = edges coming out of  way  

// wieghted graph = theyre are wieghted writeen on edges(like numbers) default wieght is 1 

/// path = squence of nodes reaching (nodes written will not repeat)

// cyclic graph = when we create a path in which we reach the node which we written in previous order also. (like a-b-c-d and we d-a this cyclic graph)

/// TYPES OF REPRESENATATION 

/// i) adjacency matrix 
///  in this 2d matrix is made....
/// space complexity = O(n^2)

/// ii) adjacency list 
// in this we write the node connected with one and another in the form of list.



#include <iostream>
#include <unordered_map>
#include <list>
using namespace std;

class graph {
public:
    unordered_map<int, list<int>> adj; // here we mapping a number with another number 

    void addEdge(int u, int v, bool direction) { // u and v are edges and bool for undirected and directed graph 
        // direction = 0 -> undirected graph
        // direction = 1 -> directed graph

        // creating an edge from u to v 
        adj[u].push_back(v); // created 
        if (direction == 0) { // checking directed or undirected 
            adj[v].push_back(u); // corrected from push.back to push_back
        }
    }

    void printAdjList() { // Removed the duplicate declaration
        for (auto i : adj) {
            cout << i.first << " -> ";
            for (auto j : i.second) {
                cout << j << ", ";
            }
            cout << endl; // Move to the next line after printing the list for a node
        }
    }
};

int main() {
    int n;
    cout << "Enter the number of nodes: " << endl;
    cin >> n;

    int m;
    cout << "Enter the number of edges: " << endl;
    cin >> m;

    graph g;

    for (int i = 0; i < m; i++) {
        int u, v;
        cout << "Enter edge (u v): "; // Prompt for edge input
        cin >> u >> v;

        // Ask the user for the type of graph
        int direction;
        cout << "Is the graph directed (1) or undirected (0)? ";
        cin >> direction;

        // creation of graph based on user input
        g.addEdge(u, v, direction);
    }

    // printing graph 
    g.printAdjList();

    return 0;
}

#include <iostream>
#include <vector>

using namespace std; // Allows us to use standard library names without the std:: prefix

class Graph {
private:
    int V; // Number of vertices in the graph
    bool directed; // Indicates if the graph is directed
    vector<vector<int>> adjacencyMatrix; // 2D vector to store the adjacency matrix

public:
    // Constructor to initialize the graph
    Graph(int vertices, bool isDirected = false) : V(vertices), directed(isDirected) {
        // Resize the adjacency matrix to V x V and initialize all values to 0
        adjacencyMatrix.resize(V, vector<int>(V, 0));
    }

    // Method to add an edge from vertex u to vertex v with an optional weight
    void addEdge(int u, int v, int weight = 1) {
        adjacencyMatrix[u][v] = weight; // Set the weight for the edge from u to v
        if (!directed) {
            adjacencyMatrix[v][u] = weight; // For undirected graph, set the weight for the edge from v to u
        }
    }

    // Method to display the adjacency matrix
    void display() {
        // Iterate through each row of the adjacency matrix
        for (const auto& row : adjacencyMatrix) {
            // Print each value in the row
            for (int val : row) {
                cout << val << " ";
            }
            cout << endl; // Move to the next line after printing a row
        }
    }
};

int main() {
    // Create an undirected graph with 5 vertices
    Graph g(5, false);

    // Add edges to the undirected graph
    g.addEdge(0, 1);
    g.addEdge(0, 4);
    g.addEdge(1, 4);
    g.addEdge(1, 3);
    g.addEdge(3, 4);

    // Display the adjacency matrix for the undirected graph
    cout << "Adjacency Matrix for the Undirected Graph:" << endl;
    g.display();

    // Create a directed graph with 5 vertices
    Graph gDirected(5, true);

    // Add edges to the directed graph
    gDirected.addEdge(0, 1);
    gDirected.addEdge(1, 2);
    gDirected.addEdge(2, 0);
    gDirected.addEdge(3, 4);

    // Display the adjacency matrix for the directed graph
    cout << "\nAdjacency Matrix for the Directed Graph:" << endl;
    gDirected.display();

    return 0; // Indicate that the program ended successfully
}

// Author : Khadiza Sultana
#include<iostream>
using namespace std;

int decimalToBinary(int decNum){
    int ans = 0, pow = 1;
    while(decNum > 0){
        int rem = decNum % 2; // documenting the remainder for example for 3 % 2 = 1
        decNum /= 2; // determining the divisor 3 / 2 = 1
        ans += (rem * pow); // determining the position for the remainder as it goes from down to up
        pow *= 10; // updating the position of the digits
    }
    return ans;
}

int main(){
    int decNum = 50;  
    cout << decimalToBinary(decNum) << endl;
    return 0;
}

// Khadiza Sultana
#include<iostream>
using namespace std;
int primecheck(int n){
    bool isprime = true;
    for(int i = 2; i * i <= n; i++){
        if(n % i == 0){
            isprime = false;
            return false;
        }
    }
    if(isprime)
       return true;
}
void printprime(int num){
    for(int i = 2; i <= num; i++){
        if(primecheck(i))
           cout << i << " ";
    }
}
int primecount(int num){
    int count = 0;
    for(int i = 2; i <= num; i++){
        if(primecheck(i))
           count++;
    }
    return count;
}
int main(){
    int num;
    cin >> num;
    printprime(num);
    cout << endl;
    cout << primecount(num) << endl;
    return 0;
}

CODE:

import numpy as np

import matplotlib.pyplot as plt

Generate synthetic data for linear regression (same as before)

np.random.seed (42)

X2 np.random.rand(100, 1) 100 random points for X y-4+3x np.random.randn(100, 1)y4+ 3x noise

Plot the generated data

plt.scatter (X, y)

plt.xlabel('X')

plt.ylabel('y')

plt.title('Synthetic Linear Data')

Adagrad Gradient Descent Function for Linear Regression

plt.show()

def adagrad_gradient descent (X, y, learning_rate=0.01, n_epochs-50,

epsilon-le-8):

mlen (X)

theta np.random.randn(2, 1) Random initialization of

parameters

Add bias term (column of ones) to X X_bnp.c_(np.ones((m, 1)), X)

Initialize accumulated squared gradients to 0

accumulated_gradients np.zeros((2, 1)) epoch in range (n epochs):

for gradients2/m X b.T.dot (X_b.dot (theta) y) # Compute

the gradients accumulated_gradients + gradients**2 Accumulate the squared

gradients adjusted_learning_rate learning_rate / (np.sqrt(accumulated gradients) epsilon) Adjust learning rate theta theta adjusted_learning_rate gradients Update

parameters (theta)

return theta

Apply AdaGrad to fit the model

theta_adagradadagrad_gradient_descent (X, y, learning_rate=0.1,

n_epochs-100) Display the resulting parameters (theta) print (f"AdaGrad estimated parameters

: Intercept (theta) = (theta_adagrad [0] [0]:.4f), Slope (thetal) (theta_adagrad [1][0]:.4f)") #Plot the fitted line

X new np.array([[0], [2]]) New data to plot the line

X new b np.c (np.ones((2, 1)), X_new] Add bias term to new data

y predict X_new_b.dot (theta_adagrad) Predict y based on new X plt.plot (X_new, y_predict, "r-", linewidth=2, label="Predictions")

plt.plot (X, y, "b.")

plt.xlabel('X')

plt.title('Linear Regression with AdaGrad')

plt.legend (

plt.ylabel('y')

)plt.show()

internal final class NW_AutoApproveWF
{
    public UserId GetSetpUser(Common Table)
    {
        WorkflowTrackingStatusTable WorkflowTrackingStatusTable;
        WorkflowTrackingTable       WorkflowTrackingTable;

        select firstonly WorkflowTrackingStatusTable
            join WorkflowTrackingTable
            order by WorkflowTrackingTable.CreatedDateTime desc
            where WorkflowTrackingTable.WorkflowTrackingStatusTable == WorkflowTrackingStatusTable.RecId
            && WorkflowTrackingStatusTable.ContextTableId == Table.TableId
            && WorkflowTrackingStatusTable.ContextRecId == Table.RecId
            && WorkflowTrackingTable.TrackingContext   == WorkflowTrackingContext::WorkItem;

        return WorkflowTrackingTable.User;
    }

    public void AutoApprove(Common Table, str Comment, str menuItem)
    {
        WorkflowWorkItemTable       WorkflowWorkItemTable;
        ;
        select WorkflowWorkItemTable
            where WorkflowWorkItemTable.Type == WorkflowWorkItemType::WorkItem
            && WorkflowWorkItemTable.Status == WorkflowWorkItemStatus::Pending
            && WorkflowWorkItemTable.RefTableId == Table.TableId
            && WorkflowWorkItemTable.RefRecId == Table.RecId;

        WorkflowWorkItemActionManager::dispatchWorkItemAction(
            WorkflowWorkItemTable,
            Comment,
            this.GetSetpUser(Table),
            WorkflowWorkItemActionType::Complete,
            menuItem);
    }

}

#include <iostream>
#include <queue>

using namespace std;

class heap {
public:
    int arr[100];
    int size;

    heap() {
        arr[0] = -1;
        size = 0;
    }

    void insert(int val) {
        size = size + 1;
        int index = size;
        arr[index] = val;
        while (index > 1) {
            int parent = index / 2;

            if (arr[parent] < arr[index]) {
                swap(arr[parent], arr[index]);
                index = parent;
            } else {
                return;
            }
        }
    }

    void print() {
        for (int i = 1; i <= size; i++) {
            cout << arr[i] << " ";
        }
        cout << endl;
    }

    void deletefromHeap() {
        if (size == 0) {
            cout << "nothing to delete " << endl;
            return;
        }

        // Step 1: Replace root with last element
        arr[1] = arr[size];
        size--;

        // Step 2: Take root to its correct position
        int i = 1;
        while (i <= size) {
            int leftIndex = 2 * i;
            int rightIndex = 2 * i + 1;
            int largest = i;

            // Check if left child exists and is greater
            if (leftIndex <= size && arr[largest] < arr[leftIndex]) {
                largest = leftIndex;
            }

            // Check if right child exists and is greater
            if (rightIndex <= size && arr[largest] < arr[rightIndex]) {
                largest = rightIndex;
            }

            // If largest is still the parent node, break the loop
            if (largest == i) {
                break;
            }

            // Swap with the largest child and continue down the heap
            swap(arr[i], arr[largest]);
            i = largest;
        }
    }
};

// Heapify function to maintain max heap property
void heapify(int arr[], int n, int i) {
    int largest = i;
    int left = 2 * i;
    int right = 2 * i + 1;

    if (left <= n && arr[largest] < arr[left]) {
        largest = left;
    }
    if (right <= n && arr[largest] < arr[right]) {
        largest = right;
    }

    // If the largest element is not the parent node
    if (largest != i) {
        swap(arr[largest], arr[i]);
        heapify(arr, n, largest);
    }
}

// Heap Sort function to sort the array
void heapSort(int arr[], int n) {
    int size = n;

    // While the heap size is greater than 1
    while (size > 1) { // removed semicolon here
        // Step 1: Swap the last element with the root
        swap(arr[size], arr[1]);
        
        // Step 2: Reduce heap size by 1
        size--;

        // Call heapify on the reduced heap
        heapify(arr, size, 1);
    }
}

int main() {
    heap h;
    h.insert(6);
    h.insert(54);
    h.insert(57);
    h.insert(59);
    h.insert(58);
    h.print();

    // Delete the root of the heap
    h.deletefromHeap();
    cout << "After deleting root: ";
    h.print();

    // Example array to demonstrate heapify and heap sort
    int arr[6] = {-1, 54, 53, 55, 52, 50};
    int n = 5;

    // Build the heap
    for (int i = n / 2; i > 0; i--) {
        heapify(arr, n, i);
    }
    cout << "PRINTING THE ARRAY AFTER HEAPIFY" << endl;
    for (int i = 1; i <= n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    // Perform heap sort
    heapSort(arr, n);
    cout << "Array after heap sort: ";
    for (int i = 1; i <= n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    
    cout << "priority queueu"<< endl;
    
    // max heap 
    priority_queue<int> pq;
    pq.push(6);
    pq.push(10);
    pq.push(57);
    pq.push(5);
    
    cout << "element at top "<<pq.top() << endl;
    pq.pop();
    cout << "element at top "<<pq.top() << endl;
    cout << "size of  "<<pq.size() << endl;
    if(pq.empty()){
        cout << "empty" << endl;
    }
    else{
        cout << "not empty" << endl;
    }
     
    // Min heap using priority_queue with greater comparator
    priority_queue<int, vector<int>, greater<int>> minheap;

    // Adding elements to the min heap
    minheap.push(10);
    minheap.push(33);
    minheap.push(43);
    minheap.push(67);
    minheap.push(75);
    
    // Displaying the top element in the min heap
    cout << "Element at top: " << minheap.top() << endl;

    // Removing the top element
    minheap.pop();

    // Displaying the new top element
    cout << "Element at top after pop: " << minheap.top() << endl;

    // Displaying the size of the min heap
    cout << "Size of minheap: " << minheap.size() << endl;

    // Checking if the min heap is empty
    if (minheap.empty()) {
        cout << "Minheap is empty" << endl;
    } else {
        cout << "Minheap is not empty" << endl;
    }
}

rm -rf .git

{
	"blocks": [
		{
			"type": "header",
			"text": {
				"type": "plain_text",
				"text": ":star: Xero Boost Days! :star:"
			}
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "Canberra! Please see below for what's on this week! "
			}
		},
		{
			"type": "divider"
		},
		{
			"type": "header",
			"text": {
				"type": "plain_text",
				"text": ":calendar-date-13: Wednesday, 14th November",
				"emoji": true
			}
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "\n:Lunch: *Lunch*: Provided in our suite from *12pm*."
			}
		},
		{
			"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=Y19jYzU3YWJkZTE4ZTE0YzVlYTYxMGU4OThjZjRhYWQ0MTNhYmIzMDBjZjBkMzVlNDg0M2M5NDQ4NDk3NDAyYjkyQGdyb3VwLmNhbGVuZGFyLmdvb2dsZS5jb20|*Canberra Social Calendar*>, and get ready to Boost your workdays!\n\nLove,\nWX Team :party-wx:"
			}
		}
	]
}

{
	"blocks": [
		{
			"type": "section",
			"block_id": "heading",
			"text": {
				"type": "mrkdwn",
				"text": "*🌟 Boost Days Extended 🌟*"
			}
		},
		{
			"type": "section",
			"block_id": "intro",
			"text": {
				"type": "mrkdwn",
				"text": "Hey Brisbane!\n\nThanks to your incredible feedback, we’re thrilled to announce that our Boost Days program is extended through March 2025! With your input, we’ve refined Boost Days to focus on the experiences that bring our Xeros the most enjoyment. To maximise what you love, we’re saying farewell to Afternoon Tea and Wellbeing activities. But don't worry - our awesome Wellbeing team and Wellbeing Champions in each region will continue to offer and promote these initiatives.\n\n*Here’s what’s changing—and what’s here to stay:*"
			}
		},
		{
			"type": "section",
			"block_id": "meals",
			"text": {
				"type": "mrkdwn",
				"text": "*🍽️ More Meals, More Connections*\nWe’re adding more deliciousness to the menu!\nGet ready for both a breakfast and a light lunch each week.\nNow you'll have two opportunities to come together and refuel with your fellow Xeros."
			}
		},
		{
			"type": "section",
			"block_id": "social-events",
			"text": {
				"type": "mrkdwn",
				"text": "*🎉 Social Happy Hour*\nHappening every two weeks with a rebranded style. Enjoy drinks and tasty nibbles - this regular schedule makes it easier than ever to connect and have some fun!"
			}
		},
		{
			"type": "section",
			"block_id": "cafe-partnership",
			"text": {
				"type": "mrkdwn",
				"text": "*☕ Café Partnership*\nContinue to enjoy your favourite café-style beverages from _Edwards_. Whether it's a latte, tea or a hot chocolate, it's the perfect pick-me-up through your Boost day!"
			}
		},
		{
			"type": "section",
			"block_id": "closing",
			"text": {
				"type": "mrkdwn",
				"text": "Boost Days have always been about giving you time to recharge and reconnect, and we’re so excited to bring you an even better experience with these updates.\n\nSee you at the next Boost Day! 🌟\n\nWith love,\nThe WX Team :party-wx:"
			}
		}
	]
}

{
	"blocks": [
		{
			"type": "section",
			"block_id": "heading",
			"text": {
				"type": "mrkdwn",
				"text": "*🌟 Boost Days Extended 🌟*"
			}
		},
		{
			"type": "section",
			"block_id": "intro",
			"text": {
				"type": "mrkdwn",
				"text": "Hey Sydney!\n\nThanks to your incredible feedback, we’re thrilled to announce that our Boost Days program is extended through March 2025! With your input, we’ve refined Boost Days to focus on the experiences that bring our Xeros the most enjoyment. To maximise what you love, we’re saying farewell to Afternoon Tea and Wellbeing activities. But don't worry - our awesome Wellbeing team and Wellbeing Champions in each region will continue to offer and promote these initiatives.\n\n*Here’s what’s changing—and what’s here to stay:*"
			}
		},
		{
			"type": "section",
			"block_id": "meals",
			"text": {
				"type": "mrkdwn",
				"text": "*🍽️ More Meals, More Connections*\nWe’re adding more deliciousness to the menu!\nGet ready for both a breakfast and a light lunch each week.\nNow you'll have two opportunities to come together and refuel with your fellow Xeros."
			}
		},
		{
			"type": "section",
			"block_id": "social-events",
			"text": {
				"type": "mrkdwn",
				"text": "*🎉 Social Happy Hour*\nHappening every two weeks with a rebranded style. Enjoy drinks and tasty nibbles - this regular schedule makes it easier than ever to connect and have some fun!"
			}
		},
		{
			"type": "section",
			"block_id": "cafe-partnership",
			"text": {
				"type": "mrkdwn",
				"text": "*☕ Café Partnership*\nContinue to enjoy your favourite café-style beverages from _Elixir_. Whether it's a latte, tea or a hot chocolate, it's the perfect pick-me-up through your Boost day!"
			}
		},
		{
			"type": "section",
			"block_id": "closing",
			"text": {
				"type": "mrkdwn",
				"text": "Boost Days have always been about giving you time to recharge and reconnect, and we’re so excited to bring you an even better experience with these updates.\n\nSee you at the next Boost Day! 🌟\n\nWith love,\nThe WX Team :party-wx:"
			}
		}
	]
}

{
	"blocks": [
		{
			"type": "section",
			"block_id": "boost_days_heading",
			"text": {
				"type": "mrkdwn",
				"text": "*🌟 Introducing Boost Days🌟*"
			}
		},
		{
			"type": "section",
			"block_id": "boost_days_intro",
			"text": {
				"type": "mrkdwn",
				"text": "Hey Orange County! \n\nWe’re excited to launch Boost Days, starting on the [INSERT DATE] through March 2025! \nThese days are designed to give you the chance to recharge and connect with your fellow Xeros."
			}
		},
		{
			"type": "section",
			"block_id": "whats_staying",
			"text": {
				"type": "mrkdwn",
				"text": "*Starting the week of November 25th, here's what to expect:*\n\n🍽️ *Weekly Meals*: Join us each week on a [INSERT DAY] for a light lunch - a perfect time to gather over delicious food and even better company."
			}
		},
		{
			"type": "section",
			"block_id": "boost_days_impact",
			"text": {
				"type": "mrkdwn",
				"text": "Boost Days are all about creating moments to recharge and reconnect, and we can't wait for you to experience it!"
			}
		},
		{
			"type": "section",
			"block_id": "closing_message",
			"text": {
				"type": "mrkdwn",
				"text": "See you at the next Boost Day! 🌟\n\nWith love,\nThe WX Team :party-wx:"
			}
		}
	]
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>ProBet - Live Sports Odds</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            display: flex;
            justify-content: center;
            align-items: center;
            flex-direction: column;
            padding: 2rem;
            background-color: #f4f4f9;
        }
        h1 {
            color: #333;
            text-align: center;
        }
        .widgets-container {
            display: flex;
            gap: 2rem;
            margin-top: 2rem;
            flex-wrap: wrap;
        }
        .widget {
            border: 1px solid #ddd;
            border-radius: 8px;
            overflow: hidden;
            box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
        }
    </style>
</head>
<body>

    <h1>Welcome to ProBet - Live Sports Odds</h1>
    <p>Get real-time NFL and NBA odds from FanDuel, updated instantly.</p>

    <div class="widgets-container">
        <!-- NFL Odds Widget -->
        <div class="widget">
            <iframe
                title="NFL Odds Widget"
                style="width: 300px; height: 400px; border: none;"
                src="https://widget.the-odds-api.com/v1/sports/americanfootball_nfl/events/?accessKey=wk_e4d976ec6efe552a3fee4d580e7cd480&bookmakerKeys=fanduel&oddsFormat=american&markets=totals&marketNames=h2h%3AMoneyline%2Cspreads%3ASpreads%2Ctotals%3AOver%2FUnder">
            </iframe>
        </div>

        <!-- NBA Odds Widget -->
        <div class="widget">
            <iframe
                title="NBA Odds Widget"
                style="width: 300px; height: 400px; border: none;"
                src="https://widget.the-odds-api.com/v1/sports/basketball_nba/events/?accessKey=wk_e4d976ec6efe552a3fee4d580e7cd480&bookmakerKeys=fanduel&oddsFormat=american&markets=totals&marketNames=h2h%3AMoneyline%2Cspreads%3ASpreads%2Ctotals%3AOver%2FUnder">
            </iframe>
        </div>
    </div>

</body>
</html>

class NW_ZatcaSendInvoice
{
    public static void main(Args _args)
    {
        int ICVSequence;
        str PIH,ICV,UUID;
        NW_InvoiceICVSequence InvoiceICVSequence;
        CustInvoiceJour _CustInvoiceJour,CustInvoiceJour1;
        ProjInvoiceJour _ProjInvoiceJour,ProjInvoiceJour;
        NW_EInvoice EInvoice;
        CustTable CustTable;
        NW_ZatcaApiType ZatcaApiType;
        CustInvoiceTable CustInvoiceTable;
        NW_CertificateAPI CertificateAPI;

        NW_EInvoicesView EInvoicesView = _args.record();
        CertificateAPI = NW_CertificateAPI::Find();
        ZatcaApiType = _args.parmEnum();
      

        update_recordset EInvoice setting
            Latest = NoYes::No
            where EInvoice.InvoiceId == EInvoicesView.InvoiceId;

       

        UUID = strrem(guid2str(newguid()), '{}'); //Winapi::createGUID();
        ICVSequence = CertificateAPI.ICVSequence +1;
        ICV = int2Str(ICVSequence);

        if(!CertificateAPI.PIH)
        {
            PIH ="NWZlY2ViNjZmZmM4NmYzOGQ5NTI3ODZjNmQ2OTZjNzljMmRiYzIzOWRkNGU5MWI0NjcyOWQ3M2EyN2ZiNTdlOQ==";

        }
        else
        {
            PIH =   CertificateAPI.PIH;
        }


        update_recordset CertificateAPI setting
                PIH = PIH,
                ICVSequence = ICVSequence,
               UUID = UUID;
             
       

       


        if(EInvoicesView.Table_Id == any2Str(tableNum(ProjInvoiceJour)))
        {

            NW_EInvoice::newProjInvoice(EInvoicesView,true, NW_EInvoiceStatus::CreatedFailed,ICV,PIH,UUID);
            new MenuFunction(menuItemActionStr(NW_EInvoiceProcessorCreateXMLUpdate), MenuItemType::Action).run(_args);

            NW_ZatcaSendInvoice::ClearenceAPI(EInvoicesView.InvoiceRecId,ICV,ICVSequence,any2Int(EInvoicesView.Table_Id));

        }

        else
        {

            NW_EInvoice::newCustInvoice(EInvoicesView,true, NW_EInvoiceStatus::CreatedFailed,ICV,PIH,UUID);

            new MenuFunction(menuItemActionStr(NW_EInvoiceProcessorCreateXMLUpdate), MenuItemType::Action).run(_args);

       
        NW_ZatcaSendInvoice::ClearenceAPI(EInvoicesView.InvoiceRecId,ICV,ICVSequence,any2Int(EInvoicesView.Table_Id));
          
        

        }
       


    }

    public static void ClearenceAPI(RecId InvoiceRecId,str ICV,int ICVSequence,tableid _TableId)
    {
        RetailWebRequest    webRequest;
        RetailWebResponse   response;
        str                 rawResponse, ref;
        Map                 responseData;
        RetailCommonWebAPI webApi;
        str UUID,xmlInvoice;
        System.IO.Stream streamstr,responsestr;
        System.IO.StreamReader reader;
        NW_EInvoice EInvoice,_EInvoice;
        CustInvoiceJour CustInvoiceJour;
        ProjInvoiceJour ProjInvoiceJour;
        Map responseMap;
        MapEnumerator       mapEnumerator;
        str HashInvoice,clearedInvoice;
        NW_CertificateAPI CertificateAPI;
        XmlDocument doc = new XmlDocument();
        XmlNodeList nodeList;
       


        ;

        select * from EInvoice where EInvoice.CustInvoiceJourRecId == InvoiceRecId && EInvoice.ICV == ICV
            && EInvoice.Latest == NoYes::Yes;

       
        select * from CertificateAPI;

        UUID = EInvoice.UUID;
        xmlInvoice = System.Convert::ToBase64String(System.Text.Encoding::UTF8.GetBytes(EInvoice.XMLOutgoing));

        str json = "{\"uuid\": \"" + UUID + "\" , \"xmlInvoice\": \"" + xmlInvoice + "\"}";


        webApi = RetailCommonWebAPI::construct();

        // str authHeader = @'SecretToken: '+"h!YZWFP!b2L6YyjZjjUhEK=A5WnqJ_9E";
        str authHeader = @'SecretToken: '+CertificateAPI.SecretToken;


        // response =  webApi.makePostRequest("https://zatca.netways1.com/api/Zatca/InvoiceClearance",json,authHeader,"application/json");
        response =  webApi.makePostRequest(CertificateAPI.ClearenceAPIURL,json,authHeader,"application/json");

        update_recordset _EInvoice setting
            ResponseAPI = response.parmData(),
            InvoiceBase64 = xmlInvoice
            where _EInvoice.RecId == EInvoice.RecId;


       // info(response.parmData());

        if(response.parmHttpStatus() == 200)
        {
           
            responseMap = RetailCommonWebAPI::getMapFromJsonString(response.parmData());
            mapEnumerator = responseMap.getEnumerator();

            while (mapEnumerator.moveNext())
            {
                if(mapEnumerator.currentKey() == "invoiceHash")
                {
                    HashInvoice = strRem(mapEnumerator.currentValue(),"]");
                    HashInvoice = strRem(mapEnumerator.currentValue(),"[");
                }

                if(mapEnumerator.currentKey() == "clearedInvoice")
                {
                    clearedInvoice = strRem(mapEnumerator.currentValue(),"]");
                    clearedInvoice = strRem(mapEnumerator.currentValue(),"[");



                    doc.loadXml(System.Text.Encoding::UTF8.GetString(System.Convert::FromBase64String(clearedInvoice)));

                    nodeList = doc.getElementsByTagName('cac:AdditionalDocumentReference');
                }

            }

           
            if(_TableId == (tableNum(ProjInvoiceJour)))
            {
                update_recordset ProjInvoiceJour setting
                NW_ZatcaStatus = NW_ZatcaStatus::Cleared,
                QRCode_SA = nodeList.item(2).childNodes().item(1).innerText(),
                ZatcaClearedInvoice = clearedInvoice,
                ZatcaClearedInvoiceDate = systemDateGet()
            where ProjInvoiceJour.RecId == EInvoice.CustInvoiceJourRecId;
            }
            else

            {

            update_recordset CustInvoiceJour setting
                NW_ZatcaStatus = NW_ZatcaStatus::Cleared,
                QRCode_SA = nodeList.item(2).childNodes().item(1).innerText()
            where CustInvoiceJour.RecId == EInvoice.CustInvoiceJourRecId;
            }



           
            CertificateAPI.clear();
            update_recordset CertificateAPI setting
                PIH = HashInvoice,
                ICVSequence = ICVSequence;
            

            
           
            
        }


        

        else
        {
            NW_EInvoiceResponse EInvoiceResponse;
            NW_ValidationResultsResponse  ValidationResultsResponse;
            NW_ErrorMessagesResponse      ErrorMessagesResponse ;
            NW_WarningMessagesResponse    WarningMessagesResponse;
            List ErrorMessagesList,WarningMessagesList = new List(Types::Class);
            ListEnumerator ErrorMessagesListEnumerator,WarningMessagesListEnumerator;


            ValidationResultsResponse= FormJsonSerializer::deserializeObject(classNum(NW_ValidationResultsResponse),response.parmData());

            ErrorMessagesList= ValidationResultsResponse.parmerrorMessages();
            ErrorMessagesListEnumerator = ErrorMessagesList.getEnumerator();

            while (ErrorMessagesListEnumerator.moveNext())
            {
                ErrorMessagesResponse= ErrorMessagesListEnumerator.current();
                // Info(ErrorMessagesResponse.parmmessage());

                EInvoiceResponse.EInvoiceRecId = EInvoice.RecId;
                EInvoiceResponse.Massage = ErrorMessagesResponse.parmmessage();
                EInvoiceResponse.Type = "Error";
                EInvoiceResponse.insert();

            }

            WarningMessagesList = ValidationResultsResponse.parmwarningMessages();
            WarningMessagesListEnumerator = WarningMessagesList.getEnumerator();

            while (WarningMessagesListEnumerator.moveNext())
            {
                WarningMessagesResponse= WarningMessagesListEnumerator.current();
                // Info(WarningMessagesResponse.parmmessage());EInvoiceResponse.EInvoiceRecId = EInvoice.RecId;

                EInvoiceResponse.Massage = WarningMessagesResponse.parmmessage();
                EInvoiceResponse.Type = "Warning";
                EInvoiceResponse.insert();

            }



        }

      




    }

    public static void ReportingAPI(RecId InvoiceRecId,str ICV,int ICVSequence,TableId _TableId )
    {
        RetailWebRequest    webRequest;
        RetailWebResponse   response;
        str                 rawResponse, ref;
        Map                 responseData;
        RetailCommonWebAPI webApi;
        str UUID,xmlInvoice;
        System.IO.Stream streamstr,responsestr;
        System.IO.StreamReader reader;
        NW_EInvoice EInvoice,_EInvoice;
        CustInvoiceJour CustInvoiceJour;
        ProjInvoiceJour ProjInvoiceJour;
        Map responseMap;
        MapEnumerator       mapEnumerator;
        str HashInvoice,SignedInvoice;
        NW_CertificateAPI CertificateAPI;
        XmlDocument doc = new XmlDocument();
        XmlNodeList nodeList;


        ;

        select * from EInvoice where EInvoice.CustInvoiceJourRecId == InvoiceRecId && EInvoice.ICV == ICV
            && EInvoice.Latest == NoYes::Yes;

        select * from CertificateAPI;

        UUID = EInvoice.UUID;
        xmlInvoice = System.Convert::ToBase64String(System.Text.Encoding::UTF8.GetBytes(EInvoice.XMLOutgoing));

        str json = "{\"uuid\": \"" + UUID + "\" , \"xmlInvoice\": \"" + xmlInvoice + "\"}";


        webApi = RetailCommonWebAPI::construct();

        str authHeader = @'SecretToken: '+CertificateAPI.SecretToken;

        

        //  response =  webApi.makePostRequest("https://zatca.netways1.com/api/Zatca/InvoiceReporting",json,authHeader,"application/json");
        response =  webApi.makePostRequest(CertificateAPI.ReportingAPIURL,json,authHeader,"application/json");

       
        update_recordset _EInvoice setting
            ResponseAPI = response.parmData(),
            InvoiceBase64 = xmlInvoice
            where _EInvoice.RecId == EInvoice.RecId;

        if(response.parmHttpStatus() == 200)
        {
           
            
            responseMap = RetailCommonWebAPI::getMapFromJsonString(response.parmData());

            mapEnumerator = responseMap.getEnumerator();

            while (mapEnumerator.moveNext())
            {
                if(mapEnumerator.currentKey() == "invoiceHash")
                {
                    HashInvoice = strRem(mapEnumerator.currentValue(),"]");
                    HashInvoice = strRem(mapEnumerator.currentValue(),"[");
                }

                if(mapEnumerator.currentKey() == "SignedInvoice")
                {
                    SignedInvoice = strRem(mapEnumerator.currentValue(),"]");
                    SignedInvoice = strRem(mapEnumerator.currentValue(),"[");

                    doc.loadXml(System.Text.Encoding::UTF8.GetString(System.Convert::FromBase64String(SignedInvoice)));

                    nodeList = doc.getElementsByTagName('cac:AdditionalDocumentReference');
                }

            }
            CertificateAPI.clear();

            update_recordset CertificateAPI setting
            PIH = HashInvoice,
            ICVSequence = ICVSequence;

            //if(ProjInvoiceJour::findRecId(InvoiceRecId))
            if(_TableId == (tableNum(ProjInvoiceJour)))
            {

                update_recordset ProjInvoiceJour setting
                NW_ZatcaStatus = NW_ZatcaStatus::Reported,
                QRCode_SA = nodeList.item(2).childNodes().item(1).innerText(),
                ZatcaSignedInvoice = SignedInvoice,
                ZatcaSignedInvoiceDate = systemDateGet()
            where ProjInvoiceJour.RecId == EInvoice.CustInvoiceJourRecId;
            }

            else
            {
                update_recordset CustInvoiceJour setting
                NW_ZatcaStatus = NW_ZatcaStatus::Reported,
                 QRCode_SA = nodeList.item(2).childNodes().item(1).innerText()
            where CustInvoiceJour.RecId == EInvoice.CustInvoiceJourRecId;
            }

           

           
        }

       
        else
        {
            NW_EInvoiceResponse EInvoiceResponse;
            NW_ValidationResultsResponse  ValidationResultsResponse;
            NW_ErrorMessagesResponse      ErrorMessagesResponse ;
            NW_WarningMessagesResponse    WarningMessagesResponse;
            List ErrorMessagesList,WarningMessagesList = new List(Types::Class);
            ListEnumerator ErrorMessagesListEnumerator,WarningMessagesListEnumerator;


            ValidationResultsResponse= FormJsonSerializer::deserializeObject(classNum(NW_ValidationResultsResponse),response.parmData());

            ErrorMessagesList= ValidationResultsResponse.parmerrorMessages();
            ErrorMessagesListEnumerator = ErrorMessagesList.getEnumerator();

            while (ErrorMessagesListEnumerator.moveNext())
            {
                ErrorMessagesResponse= ErrorMessagesListEnumerator.current();
                // Info(ErrorMessagesResponse.parmmessage());

                EInvoiceResponse.EInvoiceRecId = EInvoice.RecId;
                EInvoiceResponse.Massage = ErrorMessagesResponse.parmmessage();
                EInvoiceResponse.Type = "Error";
                EInvoiceResponse.insert();

            }

            WarningMessagesList = ValidationResultsResponse.parmwarningMessages();
            WarningMessagesListEnumerator = WarningMessagesList.getEnumerator();

            while (WarningMessagesListEnumerator.moveNext())
            {
                WarningMessagesResponse= WarningMessagesListEnumerator.current();
                // Info(WarningMessagesResponse.parmmessage());EInvoiceResponse.EInvoiceRecId = EInvoice.RecId;

                EInvoiceResponse.Massage = WarningMessagesResponse.parmmessage();
                EInvoiceResponse.Type = "Warning";
                EInvoiceResponse.insert();

            }



        }


        


    }

    public static void ValidateAPI(RecId CustInvoiceJourRecId,str ICV)
    {
        RetailWebRequest    webRequest;
        RetailWebResponse   response;
        str                 rawResponse, ref;
        Map                 responseData;
        RetailCommonWebAPI webApi;
        str UUID,xmlInvoice;
        System.IO.Stream streamstr,responsestr;
        System.IO.StreamReader reader;
        NW_EInvoice EInvoice,_EInvoice;
        CustInvoiceJour CustInvoiceJour;


        ;

        select * from EInvoice where EInvoice.CustInvoiceJourRecId == CustInvoiceJourRecId && EInvoice.ICV == ICV
            && EInvoice.Latest == NoYes::Yes;

           

        UUID = EInvoice.UUID;
        xmlInvoice = System.Convert::ToBase64String(System.Text.Encoding::UTF8.GetBytes(EInvoice.XMLOutgoing));

        str json = "{\"uuid\": \"" + UUID + "\" , \"xmlInvoice\": \"" + xmlInvoice + "\"}";


        webApi = RetailCommonWebAPI::construct();

        str authHeader = @'SecretToken: '+"h!YZWFP!b2L6YyjZjjUhEK=A5WnqJ_9E";

        response =  webApi.makePostRequest("https://zatca.netways1.com/api/Zatca/InvoiceCompliance",json,authHeader,"application/json");

            update_recordset _EInvoice setting
            ResponseAPI = response.parmData()
            where _EInvoice.RecId == EInvoice.RecId;

       


    }

}

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2);

//Initialize the pins
int moisture = A0;
int manual = A2;
int relay = 8;

//Setup
void setup() {
  pinMode(relay, OUTPUT);
  lcd.init();
  lcd.backlight();
  lcd.setCursor(2, 0);
  lcd.print("Initializing");
  lcd.setCursor(0, 1);
  lcd.print("STYRERIUM MODULE");
  Serial.begin(9600);
  delay(10000);

}
void loop() {
  lcd.clear();
  //Convert to percentage
  int moistureValue = analogRead(moisture);
  int moisturePercent = map(moistureValue, 0, 1023, 100, 0);
  int manualValue = analogRead(manual);
  int manualPercent = map(manualValue, 0, 1023, 0, 100);
  //Relay control
  if (moisturePercent < 13 || moisturePercent < manualPercent) {
    digitalWrite(relay, HIGH);
  } else {  //Turn off relay
    digitalWrite(relay, LOW);
  }
  //Displaying the stats
  lcd.setCursor(0, 0);
  lcd.print("Moisture: ");
  lcd.setCursor(12, 0);
  lcd.print(moisturePercent);
  lcd.print("%");
  //Manual watering display
  lcd.setCursor(0, 1);
  lcd.print("Manual: ");
  lcd.setCursor(12, 1);
  lcd.print(manualPercent);
  lcd.print("%");
  delay(100);
}

#include <Wire.h>
#include "DHT.h"
#include <LiquidCrystal_I2C.h>
//Define DHT pin and type
#define DHTPIN 9
#define DHTTYPE DHT11
//Initialize the sensor and LCD
LiquidCrystal_I2C lcd(0x27, 16, 2);
DHT dht(DHTPIN, DHTTYPE);

const int pumpPin = 8;
const int soilMoisturePin = A0;
const int potentiometerPin = A2;
unsigned long pumpStartTime = 0;  // unsigned: only >=0
bool pumpRunning = false;

void setup() {
  lcd.init();
  lcd.backlight();
  dht.begin();

  pinMode(pumpPin, OUTPUT);
  pinMode(soilMoisturePin, INPUT);
  pinMode(potentiometerPin, INPUT);
  lcd.setCursor(2, 0);
  lcd.print("Initializing");
  lcd.setCursor(0, 1);
  delay(2000);
  lcd.clear();
}

void loop() {
  int moistureValue = analogRead(soilMoisturePin);        // Read current soil moisture level
  int potentiometerValue = analogRead(potentiometerPin);  // Read potentiometer value
  int targetMoisturePercent;
  // Map values to percentage
  int moisturePercent = map(moistureValue, 1023, 0, 0, 100);
  int potentiometerPercent = map(potentiometerValue, 0, 1023, 0, 100);
  if (potentiometerPercent >= 40) {
  targetMoisturePercent = potentiometerPercent;
  } else {
    targetMoisturePercent = 40;
  }
  // Check if pump should be running
  if (pumpRunning) {
    unsigned long elapsedTime = millis() - pumpStartTime;

    // If pump has been running for 20 seconds and soil moisture hasn't increased
    if (elapsedTime >= 20000 && moisturePercent <= 30) {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Low water! Pump");
      lcd.setCursor(0, 1);
      lcd.print("stopped.");

      // Stop the pump
      digitalWrite(pumpPin, LOW);
      pumpRunning = false;
      delay(20000);
      lcd.clear();
    }
    // Stop the pump if desired soil moisture level is reached
    else if (moisturePercent >= targetMoisturePercent) {
      digitalWrite(pumpPin, LOW);  // Stop the pump
      pumpRunning = false;

      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Plants watered!");
      lcd.setCursor(7, 1);
      lcd.print(":)");
      delay(2000);  // Display message for 2 seconds
      lcd.clear();
    } else {
      lcd.setCursor(0, 0);
      lcd.print("Pump running...");
      lcd.setCursor(0, 1);
      lcd.print("Soil: ");
      lcd.print(moisturePercent);
      lcd.print("% Man: ");
      lcd.print(potentiometerPercent);
      lcd.print("%");
    }
  } else {
    float h = dht.readHumidity();
    // Read temperature as Celsius (the default)
    float t = dht.readTemperature();
    if (isnan(h) || isnan(t)) {
      Serial.println(F("Failed to read from DHT sensor!"));
    }
    // If pump has stopped, continuously display moisture and potentiometer levels
    lcd.setCursor(0, 0);
    lcd.print("Mst:");
    lcd.print(moisturePercent);
    lcd.print("%  ");

    lcd.setCursor(8, 0);
    lcd.print("Tmp:");

    if (!isnan(t)) {
      lcd.print(t);
      lcd.print("oC ");
    }
    lcd.setCursor(8, 1);
    lcd.print("Hum:");
    if (!isnan(h)) {
      lcd.print(h);
      lcd.print("% ");
    }

    lcd.setCursor(0, 1);
    lcd.print("Man:");
    lcd.print(potentiometerPercent);
    lcd.print("% ");


    // Start the pump if potentiometerPercent is above 50% and soil is below target
    if (moisturePercent < targetMoisturePercent) {
      digitalWrite(pumpPin, HIGH);
      pumpStartTime = millis();
      pumpRunning = true;

      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Pump running...");
    }
  }

  delay(2000);  // Adjust delay as needed to update readings
}

LedgerJournalTrans  LedgerJournalTrans;
LedgerJournalTable  LedgerJournalTable;
TmpLedgerBase tmpLedgerBase;
originalDocuments originalDocuments;
VendInvoiceJour VendInvoiceJour;
VendTrans   VendTrans;
select VendTrans where VendTrans.RecId == 68719573210;
Info(strFmt("%1", VendTrans.Invoice));
originalDocuments = new Originaldocuments(VendTrans);
originaldocuments.findRelations();
tmpLedgerBase.setTmpData(originalDocuments.relations());
while select tmpLedgerBase
{
    Info(strFmt("%1", tmpLedgerBase.OriginalDocument));
    if(tmpLedgerBase.OriginalDocument == OriginalDocument::Purchase)
        Info(strFmt("%1", tmpLedgerBase.id));

}
select LedgerJournalTrans where LedgerJournalTrans.VendTransId == 68719573210;
//originalDocuments = new Originaldocuments(LedgerJournalTrans);
//originaldocuments.findRelations();
//tmpLedgerBase.setTmpData(originalDocuments.relations());
//while select tmpLedgerBase
//{
//    Info(strFmt("%1", tmpLedgerBase.id));
//}
select VendInvoiceJour
    where VendInvoiceJour.ledgerVoucher == VendTrans.Voucher
    && VendInvoiceJour.InvoiceAccount == VendTrans.AccountNum
    && VendInvoiceJour.InvoiceDate == VendTrans.TransDate;
Info(strFmt("%1", VendInvoiceJour.PurchId));

/////////// ********HEAPIFY ALGO**********////////////

// no of leaf nodes = [(n/2+1)th index to (n)th index] 
// n = is equal to the number of index  
//CONCLUSION -> we need to check only from 0 to n/2 because lower than it will be the binary tree as well beacuse of leaf node property 

// heapify function = the function which convert the tree into the heap by interchanging it ....(in this process we will not process the leaf nodes )

#include <iostream>
using namespace std;
 
class heap
{
    public:
    int arr[100];
    int size;
    
    heap()
    {
        arr[0] = -1;
        size = 0;
    }
    
    void insert(int val){
        
        size = size + 1 ;
        int index = size;
        arr[index] = val ;
        while(index > 1){
            int parent = index/2;
            
            if(arr[parent] < arr[index]){
                swap(arr[parent],arr[index]);
                index = parent;
            }
            else{
                return;
            }
        }
    }
    
    void print(){
        for(int i = 1 ; i<=size; i++){
            cout << arr[i] << " ";
        }cout<< endl;
    }
 
    void deletefromHeap()
    {
        if(size == 0){
            cout << "nothing to delete "<< endl;
            return;
        }
        
        // Step 1: Replace root with last element
        arr[1] = arr[size];
        size--;
        
        // Step 2: Take root to its correct position
        int i = 1;
        while(i <= size) // Fix: changed condition to `<= size` to avoid out of bounds
        {
            int leftIndex = 2 * i;
            int rightIndex = 2 * i + 1;
            int largest = i;
        
            // Check if left child exists and is greater
            if(leftIndex <= size && arr[largest] < arr[leftIndex])
            {
                largest = leftIndex;
            }
 
            // Check if right child exists and is greater
            if(rightIndex <= size && arr[largest] < arr[rightIndex])
            {
                largest = rightIndex;
            }
 
            // If largest is still the parent node, break the loop
            if(largest == i) {
                break;
            }
 
            // Swap with the largest child and continue down the heap
            swap(arr[i], arr[largest]);
            i = largest;
        }
    }
};
void heapify(int arr[], int n , int i ){
    int largest = i ;
    int left = 2*i;
    int right = 2*i + 1;
    
    if(left < n && arr[largest] < arr[left]){
        largest = left;
    }
    if(right < n && arr[largest] < arr[right]){
        largest = right;
    }
    if(largest != 1){
        swap(arr[largest],arr[i]);
        heapify(arr, n , largest);
    }
    
}
 
int main()
{
    heap h;
    h.insert(6);
    h.insert(54);
    h.insert(57);
    h.insert(59);
    h.insert(58);
    h.print();
    
    // Delete the root of the heap
    h.deletefromHeap();
    cout << "After deleting root: ";
    h.print();
    
    int arr[6] = {-1 , 54, 53 ,55, 52, 50 };
    int n = 5;
    for(int i = n/2 ; i>0 ; i--){
        heapify(arr , n , i);
    }
    cout << "PRINTING THE ARRAY IN NOW" << endl;
    for(int i = 1; i<n ;i++){
        cout << arr[i]<< endl;
    }
    cout << endl;
    
    return 0;
}

parse_git_branch() {
    git branch 2> /dev/null | sed -n -e 's/^\* \(.*\)/[\1]/p'
}
COLOR_DEF='%f'
COLOR_USR='%F{15}'
COLOR_DIR='%F{120}'
COLOR_GIT='%F{39}'
NEWLINE=$'\n'
setopt PROMPT_SUBST
export PROMPT='${COLOR_USR}%n@%M ${COLOR_DIR}%d ${COLOR_GIT}$(parse_git_branch)$

export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"  # This loads nvm
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"  # This load$


# Load Angular CLI autocompletion.
source <(ng completion script)

define('DISALLOW_FILE_EDIT', true);
define('DISALLOW_FILE_MODS', true);

/-----------remove dashboard menu globaly-------------------/

add_action('admin_menu', 'plt_hide_woocommerce_menus', 71);
function plt_hide_woocommerce_menus() {
    global $submenu , $menu;
    remove_menu_page( 'index.php' );
        remove_menu_page( 'edit-comments.php' );
        remove_menu_page( 'options-general.php' );
        remove_menu_page( 'themes.php' );
        remove_menu_page( 'plugins.php' );
        remove_menu_page( 'users.php' );
        remove_menu_page( 'tools.php' );
        remove_menu_page( 'edit.php?post_type=woodmart_sidebar' );
        remove_menu_page( 'edit.php?post_type=portfolio' );
        remove_menu_page( 'edit.php?post_type=woodmart_layout' );
        remove_menu_page( 'vc-general' );
        remove_menu_page( 'getwooplugins' );
        remove_menu_page( 'xts_theme_settings' );
        remove_menu_page( 'xts_dashboard' );
        remove_action('admin_footer', 'wp_admin_footer');
        remove_action('wp_footer', 'wp_generator');
        remove_filter('update_footer', 'core_update_footer');
        add_filter('admin_footer_text', '__return_empty_string');
}

//STRING TO ARRAY
function split(S) {
    let i = 0;
    let result = [];
    
    while(char_at(S, i) !== undefined){
        result[i] = char_at(S,i);
        i = i + 1;
    }
    
    return result;
}

//String to stream:
// your helper functions go here
function split(s) {
    let i = 0;
    let result = [];
    
    while(char_at(s, i) !== undefined){
        result[i] = char_at(s,i);
        i = i + 1;
    }
    
    return result;
}

//Alternatively:
//ARRAYS TO LIST AND LISTS TO ARRAYS
function array_to_list(arr){
    let res = null;
    const len = array_length(arr);
    for (let i = 1; i <= len; i = i + 1){
        res = pair(arr[len - i], res);
    }
    return res;
}

function string_to_list (s){
        const new_list = array_to_list(split(s));
        return new_list;
    }
function list_to_stream(lst){
        return is_null(lst)
               ? null 
               : pair(head(lst), ()=> list_to_stream(tail(lst)));
    }
function char_stream(s) {
    return list_to_stream(string_to_list(s));
}

//Searching 2 arrays for matching elements
function contains(B, A_i) {
    const len = array_length(B);
    
    for (let j = 0; j < len; j = j + 1){
    if (B[j] === A_i){
        return true;
      }
    }
    return false;
}

function num_characters_from(A, B) {
    let result = 0;
    for (let i = 0; i < array_length(A); i = i + 1){
        if (contains(B, A[i])){
            result = result + 1;
        }
    }
    return result;
}

//ARRAYS TO LIST AND LISTS TO ARRAYS
function runlength_decode(R) {
    const RA = list_to_array(R);
    const res = [];
    for (let i = 0; i < array_length(RA); i = i + 1){
    if (is_number(RA[i])){
        res[array_length(res)] = RA[i];
    } else {
        //RA[i] is a pair
        const item = head(RA[i]);
        const quantity = tail(RA[i]);
        for (let j = 0; j < quantity; j = j + 1){
            res[array_length(res)] = item;
        }
      }
    }
    return array_to_list(res);
}

function list_to_array(xs){
    const res = [];
    let current_pair = xs;
    while (!is_null(current_pair)){
        res[array_length(res)] = head(current_pair);
        current_pair = tail(current_pair);
    }
    return res;
}

function array_to_list(arr){
    let res = null;
    const len = array_length(arr);
    for (let i = 1; i <= len; i = i + 1){
        res = pair(arr[len - i], res);
    }
    return res;
}






//SEARCHING
//1. Generalised Search
function search_cond(A, cond) {
    const len = array_length(A);
    
    for (let i = 0; i < len; i = i + 1){
        if (cond(A[i])){
            return i;
        } 
    }
    return -1;
}
/*
Approach:
1. Loop through each element of array
2. Check is predicate condition returns true
3. If true, return i of A[i]
4. If no element in loop returns true, then return -1 instead.

Other case: empty array --> -1
*/


//2. INSERTION
function insert(A, pos, x){
    let len = array_length(A);
    len = len + 1;
    for (let i = len - 2; i >= pos; i = i-1){
        A[i + 1] = A[i];
    }
    A[pos] = x;
}

/*
inputs: Array, position and element

Input validity: 
- Position needs to be within array length

output: function should return inserted array, with array length modified

code structure:
1. Expand array: increase length by 1 to make space
2. Shifting: Start from last element, shift each element one spot to the right 
   until you reach position, leaving an empty space at position
3. Insert x into empty space

Loop condition: i > = pos
*/

//3. Insertion Sort
function insertion_sort(A) {
    let sorted_array = [];
    let len = array_length(A);
    
    for ( let i = 0; i < len; i=i+1){
        let x = A[i];
        let pos = search_cond(sorted_array, y => y > x);
        
        if (pos === -1) {
            pos = array_length(sorted_array);
        }
        
        insert(sorted_array, pos, x);
    }
    
    return sorted_array;
}

/*
1. Create a new array: sorted_array
2. Iterate over elements of original array
3. Use search_cond to find validity to insert into sorterd_array
*/

:target::before {
  content: "";
  display: block;
  height: 60px; /* fixed header height*/
  margin: -60px 0 0; /* negative fixed header height */
}
Or:
html {
  scroll-padding-top: 70px; /* height of sticky header */
}

Or use jquery:
var offset = $(':target').offset();
var scrollto = offset.top - 60; // minus fixed header height
$('html, body').animate({scrollTop:scrollto}, 0);

lb config noauto \
--mode "debian" \
--distribution "stretch" \
--archive-areas "main" \
\
--GNU Plus Linux-package "GNU Plus Linux-image GNU Plus Linux-headers" \
--bootloader "syslinux,grub-efi" \
--system "live" \
--binary-filesystem "fat32" \
--binary-images "iso-hybrid" \
\
--security "true" \
--updates "true" \
--backports "false" \
--apt-recommends "true" \
--apt-secure "true" \
--apt-indices "true" \
--apt-source-archives "false" \
\
--debian-installer "live" \
--debian-installer-gui "true" \
--debian-installer-distribution "stretch" \
\
--firmware-binary "true" \
--firmware-chroot "true" \
--iso-application "debian9" \
--iso-volume "debian9" \
--win32-loader "false" \
--clean \
--debug \
--verbose \
--source "false" \
"${@}"

///////////////************* HEAPS ***************/////////////////


//// WHAT IS HEAP ?
// complete binary tree comes with a complete binary tree properies as well as heap order property ...

// what is complete binary tree? 
// every level is full filled (fully filled means every parent node have 2 children and always filled from left side only  )  except the last level  nodes always added on left.. 

//// HEAPS PROPERTY
// MAX HEAP = parent ka child humesha use CHOTA honga 
// MIN HEAP = parent ka child humesha use BADA honga 

// suppose node index is i
// so, its left child will be at (2*i)th index.
// so, its right child will be at ((2*i)+1th) index.
// so, its parent will be at (i/2)


///MAP HEAP INSERTION
//STEP1 - INSERT AT THE END 
//STEP2 - COMAPRE IT WITH ITS PARENT NODE IF IT IST BIGGER THAN IT SHIFT IT TO THE TOP (FORMULA WE WILL USE PARENT = INDEX OF CHILD / 2)

// DELETION IN AN HEAP 
//STEP1 - REPALCE THE ROOT NODE WITH LAST NODE (SWAPPED)
//STEP2 - DELETE THE ROOT NODE NOW 
//STEP3 - COMPARE IT WITH ITS ALL CHILDREN AND REPLACE IT WITH MAX HEAP PROPERTY

///////////*** insertion in max heap ************///////////////
#include <iostream>
using namespace std;

class heap
{
    public:
    int arr[100];
    int size;
    
    heap()
    {
        arr[0] = -1;
        size = 0;
    }
    
    void insert(int val){
        
        size = size + 1 ;
        int index = size;
        arr[index] = val ;
        while(index > 1){
            int parent = index/2;
            
            if(arr[parent] < arr[index]){
                swap(arr[parent],arr[index]);
                index = parent;
            }
            else{
                return;
            }
        }
    }
    
    void print(){
        for(int i = 1 ; i<=size; i++){
            cout << arr[i] << " ";
        }cout<< endl;
    }

    void deletefromHeap()
    {
        if(size == 0){
            cout << "nothing to delete "<< endl;
            return;
        }
        
        // Step 1: Replace root with last element
        arr[1] = arr[size];
        size--;
        
        // Step 2: Take root to its correct position
        int i = 1;
        while(i <= size) // Fix: changed condition to `<= size` to avoid out of bounds
        {
            int leftIndex = 2 * i;
            int rightIndex = 2 * i + 1;
            int largest = i;
        
            // Check if left child exists and is greater
            if(leftIndex <= size && arr[largest] < arr[leftIndex])
            {
                largest = leftIndex;
            }

            // Check if right child exists and is greater
            if(rightIndex <= size && arr[largest] < arr[rightIndex])
            {
                largest = rightIndex;
            }

            // If largest is still the parent node, break the loop
            if(largest == i) {
                break;
            }

            // Swap with the largest child and continue down the heap
            swap(arr[i], arr[largest]);
            i = largest;
        }
    }
};

int main()
{
    heap h;
    h.insert(6);
    h.insert(54);
    h.insert(57);
    h.insert(59);
    h.insert(58);
    h.print();
    
    // Delete the root of the heap
    h.deletefromHeap();
    cout << "After deleting root: ";
    h.print();
    
    return 0;
}

/////////////////*************DELETION IN BST ***********/////////////////

///////// 3 CASES ////////////

/////// 0 CHILD = delete that node and  directlty return null


/////// 1 CHILD 
/// store the child one in temp and than delete the node and add temp one in bst 

////////2 children 
///  replace the favourable node with highest value in left child and than delete the favourable node frm tree.....
#include <iostream>
#include <queue>
using namespace std;

class Node {
public:
    int data;
    Node* left;
    Node* right;

    Node(int d) {
        this->data = d;
        this->left = NULL;
        this->right = NULL;
    }
};

Node* insertIntoBST(Node* root, int d) {
    // base case 
    if (root == NULL) {
        root = new Node(d); // Create a new node
        return root; // Return the newly created node
    }
    if (d > root->data) {
        // Insert in the right subtree
        root->right = insertIntoBST(root->right, d);
    } else {
        // Insert in the left subtree
        root->left = insertIntoBST(root->left, d);
    }
    return root; // Return the root of the subtree
}

void levelOrderTraversal(Node* root) {
    if (root == NULL) 
        return; // If the tree is empty, return

    queue<Node*> q;
    q.push(root);

    while (!q.empty()) {
        Node* temp = q.front();
        q.pop();
        cout << temp->data << " "; // Print the current node's data

        // Push left and right children into the queue
        if (temp->left) {
            q.push(temp->left);
        }
        if (temp->right) {
            q.push(temp->right);
        }
    }
    cout << endl; // Print a new line after level order traversal
}

void takeInput(Node*& root) {
    int data;
    cin >> data;

    while (data != -1) {
        root = insertIntoBST(root, data); // Update the root pointer
        
        // Print the current state of the BST after each insertion
        cout << "Current state of the BST after inserting " << data << ": ";
        levelOrderTraversal(root);
        
        cin >> data;
    }
}

void inorder(Node* root) {
    // base case
    if (root == NULL) {
        return;
    }
    inorder(root->left);
    cout << root->data << " ";
    inorder(root->right);
}

void preorder(Node* root) {
    // base case
    if (root == NULL) {
        return;
    }
    cout << root->data << " ";
    preorder(root->left);
    preorder(root->right);
}

void postorder(Node* root) {
    // base case
    if (root == NULL) {
        return;
    }
    postorder(root->left);
    postorder(root->right);
    cout << root->data << " ";
}

Node* minVal(Node* root) {
    Node* temp = root;
    
    while (temp->left != NULL) {
        temp = temp->left;
    }
    return temp;
}

Node* maxVal(Node* root) {
    Node* temp = root;
    
    while (temp->right != NULL) {
        temp = temp->right;
    }
    return temp;
}
Node* deleteFromBST(Node* root ,int val){
    // base case
    if(root == NULL){
        return root;
    }
    if(root->data == val){
        // 0 child
        if(root->left == NULL && root->right == NULL){
            delete root;
            return NULL;
            // here we directly deleting the root we want 
        }
        // 1 child
        if(root->left != NULL && root->right == NULL){
            Node* temp = root->left;
            delete root;
            return temp;
            // here we delete that root and save the children keyt into temp variable 
        }
        if(root->left == NULL && root->right != NULL){
            Node* temp = root->right;
            delete root;
            return temp;
        }
        // 2 children
        if(root->left != NULL && root->right != NULL ){
            int mini = minVal(root->right) -> data;
            root-> data = mini;
            root-> right = deleteFromBST(root->right,mini);
            return root;
            // here we take minimum from the rightleftsubtree or maximum from the leftsubtree  and copy the value of that value we taken above(MIN) and now delete that MIN value and than delete the root one which one we want tor delete  
        }
    }
    else if (root-> data > val){
        //left part me ajaio
        root->left = deleteFromBST(root->left,val);
        return root;
    }
    else{
        //right part me ajaio
        root->right = deleteFromBST(root->right,val);
        return root;
    }
}

int main() {
    Node* root = NULL;
    cout << "Enter the data for BST (end with -1): ";
    takeInput(root);
    
    cout << "printing inorder" << endl;
    inorder(root);
    
    cout << endl << "printing preorder" << endl;
    preorder(root);
    
    cout << endl << "printing postorder" << endl;
    postorder(root);
    
    cout << endl << "min value is " << minVal(root)->data << endl;
    cout << "max value is " << maxVal(root)->data << endl;
    
    cout << endl << "before deletion" << endl;
    inorder(root);
    // Corrected deletion part
    root = deleteFromBST(root, 30); // Update the root with the new tree structure after deletion
    
    cout << endl << "after deletion" << endl;
    inorder(root); // Print inorder traversal to confirm deletion
   
    
    return 0;
}

internal final class NW_NumToTxtHelper
{
    static TempStr numeralsToTxt_AR(real _num)
    {
        real    numOfPennies = decround(frac(_num), 2);
        real    test         = _num - frac(_num);
        str     zero;
        str     comma;
        str     and;
        str     cent;
        int     numOfTenths;
        str 20  ones[19], tenths[9], hundreds, thousands, millions, billions, trillions;

        int64   temp;
        str 200  returntxt;

        real modOperator(real a1, real a2)
        {
            int     tmpi;
            real    tmp1, tmp2;
            tmp1 = a1 / a2;
            tmpi = real2int(tmp1);
            tmp2 = tmpi;
            return (tmp1 - tmp2)*a2;
        }

        str doubleDigit2ARTxt(real doubledigit,boolean _pennies = false)
        {
            str     txt;
            int     firstDigit;
            real    tempdigit;

            if(_pennies)
            {
                firstDigit = doubledigit * 10;
                doubledigit = doubledigit * 100;
                if(!firstDigit)
                {
                    doubledigit = doubledigit mod 10;
                    //txt = zero + " " + ones[doubledigit];
                    txt = ones[doubledigit];
                    return txt;
                }
            }
            tempdigit = doubledigit;
            if (tempdigit >= 20)
            {
                tempdigit = tempdigit div 10;
                txt = tenths[tempdigit];
                doubledigit = doubledigit mod 10;
            }
            if (doubledigit >= 1)
            {
                txt = txt ?  (ones[doubledigit] + and + txt) : ones[doubledigit];
            }

            return txt;
        }

        real checkPower(real  _test,int64 _power)
        {
            int64   numOfPower;

            if (_test >= _power)
            {
                numOfPower = _test div _power;
                if (numOfPower >= 100)
                {
                    temp = numOfPower div 100;

                    if(temp > 9)// The validation was previously on 2
                    {
                        returntxt = returntxt ? (returntxt + and + ones[temp] + ' ' + hundreds) :(returntxt + ' ' + ones[temp] + ' ' + hundreds);
                    }

                    else
                    {
                        switch(temp)
                        {

                            Case 1:
                                returntxt = returntxt ? (returntxt + and + hundreds) : (returntxt + ' ' + hundreds);
                                break;
                            Case 2:
                                // TO DO need to insert a label for two hundred in Arabic
                                returntxt = returntxt ? (returntxt + and + "مائتين") :   returntxt + ' ' + "مائتين";
                                break;
                            Case 3:
                                // TO DO need to insert a label for three hundred in Arabic
                                returntxt = returntxt ? (returntxt + and + "ثلاثمائة") :   returntxt + ' ' + 'ثلاثمائة';
                                break;
                            Case 4:
                                // TO DO need to insert a label for four hundred in Arabic
                                returntxt = returntxt ? (returntxt + and + "اربعمائة") :   returntxt + ' ' + "اربعمائة";
                                break;
                            Case 5:
                                // TO DO need to insert a label for five hundred in Arabic
                                returntxt = returntxt ? (returntxt + and + "خمسمائة") :   returntxt + ' ' + "خمسمائة";
                                break;
                            Case 6:
                                // TO DO need to insert a label for six hundred in Arabic
                                returntxt = returntxt ? (returntxt + and + "ستمائة") :   returntxt + ' ' + "ستمائة";
                                break;
                            Case 7:
                                // TO DO need to insert a label for seven hundred in Arabic
                                returntxt = returntxt ? (returntxt + and + "سبعمائة") :   returntxt + ' ' + "سبعمائة";
                                break;
                            Case 8:
                                // TO DO need to insert a label for eight hundred in Arabic
                                returntxt = returntxt ? (returntxt + and + "ثمانمائة") :   returntxt + ' ' + "ثمانمائة";
                                break;
                            Case 9:
                                // TO DO need to insert a label for nine hundred in Arabic
                                returntxt = returntxt ? (returntxt + and + "تسعمائة") :   returntxt + ' ' + "تسعمائة";
                                break;

                        }
                    }
                    numOfPower = numOfPower mod 100;
                }
                if(numOfPower > 2 && _power > 100)
                {
                    returntxt = returntxt ?  (returntxt + and + doubleDigit2ARTxt(real2int(numOfPower))) : (returntxt  + ' ' + doubleDigit2ARTxt(real2int(numOfPower)));
                }
                else
                {
                    if(returntxt && numOfPower)
                    {
                        returntxt = returntxt + and + ' ';
                    }
                }
                switch(_power)
                {
                    case 1000000000000 :
                        {
                            if( numOfPower == 2)
                            {
                                // TO DO need to insert a label for two trillions in Arabic
                                returntxt = returntxt + "تريليونين ";
                            }
                            else
                            {
                                returntxt = numOfPower > 10 ||  numOfPower == 1 || numOfPower == 0 ? (returntxt + ' ' + trillions) : (returntxt + ' ' + "تريليونات");
                            }
                            _test = modOperator(_test, 1000000000000.00);
                            break;
                        }
                    case 1000000000 :
                        {
                            if( numOfPower == 2)
                            {
                                // TO DO need to insert a label for two billions in Arabic
                                returntxt = returntxt + "مليارين";
                            }
                            else
                            {
                                returntxt = numOfPower > 10 ||  numOfPower == 1 || numOfPower == 0 ? (returntxt + ' ' + billions) : (returntxt + ' ' + "مليارات");
                            }
                            _test = modOperator(_test, 1000000000);
                            break;
                        }
                    case 1000000 :
                        {
                            if( numOfPower == 2)
                            {
                                // TO DO need to insert a label for two Millions in Arabic
                                returntxt = returntxt + "مليونين";
                            }
                            else
                            {

                                returntxt = numOfPower > 10 || numOfPower == 1 || numOfPower == 0 ? (returntxt + ' ' + millions) : (returntxt + ' ' + "ملايين");

                            }
                            _test = modOperator(_test, 1000000);
                            break;
                        }
                    case 1000 :
                        {
                            if( numOfPower == 2)
                            {
                                // TO DO need to insert a label for two Thousands' in Arabic
                                returntxt = returntxt + "ألفين";
                            }
                            else
                            {
                                returntxt = numOfPower > 10 ||  numOfPower == 1 || numOfPower == 0  ? (returntxt + ' ' + thousands) : (returntxt + ' ' + "الاف");
                            }
                            _test = modOperator(_test, 1000);
                            break;
                        }
                    case 100 :
                        {
                            switch (numOfPower)
                            {
                                case 2:
                                    returntxt = returntxt + "مائتين";
                                    break;

                                case 3:
                                    returntxt = returntxt +"ثلاثمائة";
                                    break;

                                case 4:
                                    returntxt = returntxt + "اربعمائة";
                                    break;

                                case 5:
                                    returntxt = returntxt + "خمسمائة";
                                    break;

                                case 6:
                                    returntxt = returntxt + "ستمائة";
                                    break;

                                case 7:
                                    returntxt = returntxt + "سبعمائة";
                                    break;

                                case 8:
                                    returntxt = returntxt + "ثمانمائة";
                                    break;

                                case 9:
                                    returntxt = returntxt + "تسعمائة";
                                    break;

                                default:
                                    returntxt = returntxt + ' ' + hundreds;
                            }

                            _test = modOperator(_test, 100);
                            break;
                        }
                }

            }
            return _test;

        }

        //infolog.language("AR");

        and     = ' ' + "@SYS5534" + ' ';
        //and     = ' ' + "و" + ' ';
        comma   = "ريـال";
        //comma = "@SYS80142";
        zero    = "@SYS2068";
        cent    = "هللــه";

        ones[1] = "@SYS26620";
        ones[2] = "@SYS26621";
        ones[3] = "@SYS26622";
        ones[4] = "@SYS26626";
        ones[5] = "@SYS26627";
        ones[6] = "@SYS26628";
        ones[7] = "@SYS26629";
        ones[8] = "@SYS26630";
        ones[9] = "@SYS26631";
        ones[10] = "@SYS26632";
        ones[11] = "@SYS26633";
        ones[12] = "@SYS26634";
        ones[13] = "@SYS26635";
        ones[14] = "@SYS26636";
        ones[15] = "@SYS26637";
        ones[16] = "@SYS26638";
        ones[17] = "@SYS26639";
        ones[18] = "@SYS26640";
        ones[19] = "@SYS26641";

        tenths[1] = 'Not used';
        tenths[2] = "@SYS26643";
        tenths[3] = "@SYS26644";
        tenths[4] = "@SYS26645";
        tenths[5] = "@SYS26646";
        tenths[6] = "@SYS26647";
        tenths[7] = "@SYS26648";
        tenths[8] = "@SYS26649";
        tenths[9] = "@SYS26650";

        hundreds    = "@SYS26651";
        thousands   = "@SYS26652";
        millions    = "@SYS26653";
        billions    = "@SYS26654";
        trillions   = "@SYS101697";

        if(test == 0)
        {
            returntxt = zero;
        }
        else
        {
            test = checkPower(test, 1000000000000);
            test = checkPower(test, 1000000000);
            test = checkPower(test, 1000000);
            test = checkPower(test, 1000);
            test = checkPower(test, 100);
        }
        if(returntxt && test)
        {
            returntxt = returntxt + and + doubleDigit2ARTxt(real2int(test));
        }
        else
        {
            returntxt = returntxt + ' ' + doubleDigit2ARTxt(real2int(test));
        }
        if(numOfPennies)
        {
            //Removing the stars and addin the pound and cent wording to fullfil the Egyptian requierment
            returntxt = ' فقط ' + returntxt + ' ' + comma + ' ' + and + doubleDigit2ARTxt(numOfPennies,true) + ' ' + cent + ' لاغير ';
            //returntxt = '***' + returntxt + ' ' + comma + ' ' + doubleDigit2ARTxt(numOfPennies,true);
        }
        else
        {
            //Removing the stars and the zeros if no cents to fullfil the Egyptian requierment
            returntxt = ' فقط ' + returntxt + ' ' + comma + ' لاغير ';
            //returntxt = '***' + returntxt + ' ' + comma + ' ' + zero + ' ' + zero;
        }
        return returntxt;
    }
}

await UPDATE`MY_VARIANT`.set`DEFAULT = false`.where`APP_NAME=${item.APP_NAME}`

<script>
// Sélectionner tous les éléments avec la classe "member"
const members = document.querySelectorAll('.member');

// Ajouter un événement de clic à chaque "member"
members.forEach(member => {
    member.addEventListener('click', () => {
        // Sélectionner l'élément "card" à l'intérieur de "member"
        const card = member.querySelector('.card');
        
        // Basculer la classe "flip" uniquement sur "card" dans l'élément cliqué
        card.classList.toggle('flip');
    });
});
</script>

<div class="swiper-wrapper">
<div class="member">
<div class="card">
<section class="front" id="open"><img alt="" src="https://files.qualifio.com/library/anais_brison__onboarding_0/images/2024/studio%20page/stromae-blur.png" /></section>

<section class="back" id="close"><img alt="" src="https://files.qualifio.com/library/anais_brison__onboarding_0/images/2024/studio%20page/stromae-blur.png" /></section>
</div>
</div>

<div class="member">
<div class="card">
<section class="front" id="open"><img alt="" src="https://files.qualifio.com/library/anais_brison__onboarding_0/images/2024/studio%20page/stromae-blur.png" /></section>

<section class="back" id="close"><img alt="" src="https://files.qualifio.com/library/anais_brison__onboarding_0/images/2024/studio%20page/stromae-blur.png" /></section>
</div>
</div>

<div class="member">
<div class="card">
<section class="front" id="open"><img alt="" src="https://files.qualifio.com/library/anais_brison__onboarding_0/images/2024/studio%20page/stromae-blur.png" /></section>

<section class="back" id="close"><img alt="" src="https://files.qualifio.com/library/anais_brison__onboarding_0/images/2024/studio%20page/stromae-blur.png" /></section>
</div>
</div>

<div class="member">
<div class="card">
<section class="front" id="open"><img alt="" src="https://files.qualifio.com/library/anais_brison__onboarding_0/images/2024/studio%20page/stromae-blur.png" /></section>

<section class="back" id="close"><img alt="" src="https://files.qualifio.com/library/anais_brison__onboarding_0/images/2024/studio%20page/stromae-blur.png" /></section>
</div>
</div>

<div class="member">
<div class="card">
<section class="front" id="open"><img alt="" src="https://files.qualifio.com/library/anais_brison__onboarding_0/images/2024/studio%20page/stromae-blur.png" /></section>

<section class="back" id="close"><img alt="" src="https://files.qualifio.com/library/anais_brison__onboarding_0/images/2024/studio%20page/stromae-blur.png" /></section>
</div>
</div>
</div>

.swiper-wrapper{
	display: flex;
}

.card {
    display: grid;
    transform-style: preserve-3d;
    transition: transform 0.8s;
}

.card .front, .card .back {
    grid-area: 1 / 1;
    backface-visibility: hidden;
    display: flex;
    align-items: center;
    justify-content: center;
    font-size: 1.5rem;
}

.card .back {
    transform: rotateY(180deg);
}

.hide {
    display: none;
}

.flip {
    transform: rotateY(180deg);
}

TASK 1A
function make_k_list(k, d) {
    if (d === 0){
        return 0;
    } else { 
        const wish = make_k_list(k, d - 1); //each time an inner element is accessed, number of lists(degree) decreases by 1, while no. of elem kk is the same.
        return build_list(x=> wish, k);
    }
}

TASK 1B
function sum_k_list(klist) {
    
    if (!is_list(klist)){ //BC: if not list, return number
        return klist;
    } else {              //if list, apply recursion to get sum of internal list, continue addition.
        return accumulate ((x, acc) => sum_k_list(x) + acc, 0, klist);
    }
}
TASK 1C
function map_k_list(f, klist) {
    if (!is_list(klist)){
        return f(klist);
    } else {
        return map(x => map_k_list(f,x), klist);
    }
}
TASK 2A
function has_no_consecutive_pairs(list){
    for ( let i = 0; i < length(list) - 1; i = i + 1){
        if (list_ref(list, i) === list_ref(list, i + 1)){
            return false;
        } else {
            return true;
        }
    }
}


function route_distance(mat, route) {
    let total_distance = 0;
    if (length(route) < 2){
        return false;
    } else if (!has_no_consecutive_pairs(route)){
        return false;
    } else {
        for ( let i = 0; i < length(route) - 1; i = i + 1){
            const from = list_ref(route, i);
            const to = list_ref(route, i + 1);
            total_distance = total_distance + mat[from][to];
        }
        return total_distance;
    }

}

// Route: length of at least 2
// no repeating of houses back to back
TASK 2B
// The route_distance function for the preceding task has been
// pre-declared here for you to use in this task.
// Do not declare your own route_distance function.
/*
function route_distance(mat, route) {
    // Pre-declared
}
*/

function shortest_paper_route(n, mat, start) {

        // You can keep, modify or remove the permutations function.
    function permutations(ys) { //Ultimately generates a list of lists of all different permutations as lists
        return is_null(ys)
            ? list(null)
            : accumulate(append, null,
                map(x => map(p => pair(x, p), 
                             permutations(remove(x, ys))),
                    ys));
                    
            //permutations(remove(x, ys)): removes x, generates permutations for all other elements
            //Outer map: loops through each x in ys
                //Inner map: pairs x with every new permutation p genrated
    }       //accumulate: accumulates all different permutations(lists) in one list (becomes a list of lists)


// n is the total number of houses
// peter's house can be any
// One simple possible permutations is list(1,2, 3 ... , n)

    const route_without_start = remove(start, build_list(x => x, n));
    const all_routes_without_start = permutations(route_without_start);
    const all_routes = map ( x => append(pair(start, x), list(start)), all_routes_without_start);
    
    function filter_shortest(lst){
        let smallest_distance = Infinity;
        let smallest_permutation = null;

        for ( let i = 0; i < length(lst); i = i + 1){
            const current_distance = route_distance(mat, list_ref(lst, i));
            const current_permutation = list_ref(lst, i);
            
            if ( current_distance < smallest_distance){
                smallest_distance = current_distance;
                smallest_permutation = current_permutation;
            }
        }
        return pair(smallest_permutation, smallest_distance);
    }
    return filter_shortest(all_routes);
}

//generate list of permutations 
//Define function to return smallest distance and list using route distance
//Options:
  //1. Apply sort list, get head.
  
  
/*
Mistakes:
1. build_list : list required includes from 0 to n not 1 to n)
2. all_routes --->place pair after append to avoid a nested pair structure
3. smallest_distance variable: initialise it to infinity instead of 0
4. for loop: place return statement outside of if and for loop to not besl loop
5. for loop: starting varible should be i = 0 not 1
6. for loop: termination condition to be i < length(lst) instead of i < length(lst) - 1
    i < length(lst) - 1 : used to compare between 2 consecutive elements for sorting
    i < length(lst): used to go through the while list
7. current_distance and current_permutation should be defined as constants instead of variables
   as they shouldn't be changed within each iteration of loop
*/
TASK 3A
function make_postfix_exp(bae) {
    if (is_number(bae)){   //base case: if number, return number in array
       return [bae];
    } else {
       const left = make_postfix_exp(bae[0]);
       const right = make_postfix_exp(bae[2]);
       const op = bae[1]; //Why doesn't op require make_postfix_exp command?
       
       const result = [];
       for ( let i = 0; i < array_length(left); i = i + 1){ 
           result[array_length(result)] = left[i]; //next element of result is symbolised by array_length(result)
       } 
       
       for ( let i = 0; i < array_length(right); i = i + 1){
           result[array_length(result)] = right[i];
       }
       result[array_length(result)] = op; //no loop required, since will only have 1 element
       return result;
   }
}
    
/*
Key concepts:
1. "appending" different arrays by using a loop.
2. Rearranging elements of an array
*/
TASK 3B
let stack = []; // ionitialize stack

function eval_postfix_exp(pfe) { //evaluates through array pfe
    stack = [];
    for (let i = 0; i < array_length(pfe); i = i + 1){ //look at each element
        if(is_number(pfe[i])){ //check if current element is a number
            push(pfe[i]); //to add current elem named in pfe into stack
        } else {
            const operands = take_two(); //side effect of shortening stack, but calls the 2 most recent numbers from stack, returning in pair format
            const result = evaluate(head(operands), tail(operands), pfe[i]);  
            push(result); //add result to stack
        }
    }
    const final_result = stack[0]; //assigns value to final computed value of stack
    stack = [];       //good practice to clear stack
    return final_result;
}

function push(elem){
    stack[array_length(stack)] = elem;
}

function take_two(){
    const len = array_length(stack);
    const right = stack[len - 1]; //last elem of stack
    const left = stack[len - 2];  //2nd to last elem of stack
    const new_stack = [];         //new array to 
    for (let i = 0; i < len - 2; i = i + 1){ // for loop removes the last 2 elements, by copying every element except last 2 to new_stack
        new_stack[i]=stack[i];    //stack is then assigned to new_stack
    }
    stack = new_stack;
    return pair(left, right); 
}


//Purpose:
//1. retrieve last 2 elem from stack
//2. remove these elem ofrom stack
//3. return these 2 numbers s a pair, so they can be used in a operation

function evaluate(left, right, op){
    if (op === '+'){
        return left + right;
    }
    if (op === '-'){
        return left - right;
    }
    if (op === '*'){
        return left * right;
    }
    if (op === '/'){
        return left / right;
    }
}
///If number, add it to stack 

{
	"blocks": [
		{
			"type": "section",
			"block_id": "heading",
			"text": {
				"type": "mrkdwn",
				"text": "*🌟 Boost Days Extended 🌟*"
			}
		},
		{
			"type": "section",
			"block_id": "intro",
			"text": {
				"type": "mrkdwn",
				"text": "Hey Singapore!\n\nThanks to your incredible feedback, we’re thrilled to announce that our Boost Days program is extended through March 2025! With your input, we’ve refined Boost Days to focus on the experiences that bring our Xeros the most enjoyment. To maximise what you love, we’re saying farewell to Afternoon Tea and Wellbeing activities. But don't worry - our awesome Wellbeing team and Wellbeing Champions in each region will continue to offer and promote these initiatives.\n\n*From the week of the 25th of November, here’s what’s changing—and what’s here to stay:*"
			}
		},
		{
			"type": "section",
			"block_id": "meals",
			"text": {
				"type": "mrkdwn",
				"text": "*🍽️ More Meals, More Connections*\nWe’re adding more deliciousness to the menu!\nGet ready for both a breakfast and a light lunch each week.\nNow you'll have two opportunities to come together and refuel with your fellow Xeros."
			}
		},
		{
			"type": "section",
			"block_id": "social-events",
			"text": {
				"type": "mrkdwn",
				"text": "*🎉 Social Happy Hour*\nHappening every two weeks with a rebranded style. Enjoy drinks and tasty nibbles - this regular schedule makes it easier than ever to connect and have some fun!"
			}
		},
		{
			"type": "section",
			"block_id": "cafe-partnership",
			"text": {
				"type": "mrkdwn",
				"text": "*☕ Café Partnership*\nContinue to enjoy your favourite café-style beverages from _Group Therapy Coffee_. Whether it's a latte, tea or a hot chocolate, it's the perfect pick-me-up through your Boost day!"
			}
		},
		{
			"type": "section",
			"block_id": "closing",
			"text": {
				"type": "mrkdwn",
				"text": "Boost Days have always been about giving you time to recharge and reconnect, and we’re so excited to bring you an even better experience with these updates.\n\nSee you at the next Boost Day! 🌟\n\nWith love,\nThe WX Team :party-wx:"
			}
		}
	]
}

{
	"blocks": [
		{
			"type": "section",
			"block_id": "heading",
			"text": {
				"type": "mrkdwn",
				"text": "*🌟 Boost Days Extended 🌟*"
			}
		},
		{
			"type": "section",
			"block_id": "intro",
			"text": {
				"type": "mrkdwn",
				"text": "Hey Melbourne!\n\nThanks to your incredible feedback, we’re thrilled to announce that our Boost Days Program is extended through March 2025! \nWith your input, we’ve fine-tuned Boost Days to focus on the experiences that our Xeros enjoy most. To maximise what you love, we’re saying farewell to Afternoon Tea, Fitness Programs and Wellbeing activities.  But don't worry - our awesome Wellbeing team and the Wellbeing Champions in each region will continue to offer and promote these initiatives. \n\n* From the week of the 25th of November, here’s what’s changing—and what’s here to stay:*"
			}
		},
		{
			"type": "section",
			"block_id": "meals",
			"text": {
				"type": "mrkdwn",
				"text": "*🍽️ More Meals, More Connections*\nWe’re adding more deliciousness to the menu!\nGet ready for both a breakfast and a light lunch each week.\nNow you’ll have two opportunities to come together and refuel with your fellow Xeros."
			}
		},
		{
			"type": "section",
			"block_id": "social-events",
			"text": {
				"type": "mrkdwn",
				"text": "*🎉 Social Happy Hour*\nHappening every two weeks with a rebranded style.  Enjoy drinks and tasty nibbles - this regular schedule makes it easier than ever to connect and have some fun!"
			}
		},
		{
			"type": "section",
			"block_id": "xero-cafe",
			"text": {
				"type": "mrkdwn",
				"text": "*☕ Xero Café *\nOur skilled baristas will continue serving up your beloved café-style beverages. Sip on a latte, tea, or enjoy a sweet treat to keep you energised!"
			}
		},
		{
			"type": "section",
			"block_id": "closing",
			"text": {
				"type": "mrkdwn",
				"text": "Boost Days have always been about giving you time to recharge and reconnect, and we’re so excited to bring you an even better experience with these updates. \n\nSee you at the next Boost Day! 🌟\n\nWith love,\nThe WX Team :party-wx:"
			}
		}
	]
}

#include <stdio.h>
#include <unistd.h>   // For sleep function

#define BUCKET_CAPACITY 10  // Maximum capacity of the bucket
#define LEAK_RATE 1         // Amount of water that leaks per second

// Struct to represent the bucket
typedef struct {
    int currentWater;   // Current amount of water in the bucket
} LeakyBucket;

// Initialize the bucket by setting its water level to zero
void initBucket(LeakyBucket *bucket) {
    bucket->currentWater = 0;
}

// Function to add water to the bucket
void addWater(LeakyBucket *bucket, int water) {
    // Check if adding water would exceed the bucket's capacity
    if (bucket->currentWater + water > BUCKET_CAPACITY) {
        printf("Bucket overflow! Discarding excess water.\n");
    } else {
        bucket->currentWater += water;
        printf("Added %d units of water. Current level: %d\n", water, bucket->currentWater);
    }
}

// Function to leak water from the bucket
void leakWater(LeakyBucket *bucket) {
    // Only leak if there is water in the bucket
    if (bucket->currentWater > 0) {
        bucket->currentWater -= LEAK_RATE;
        if (bucket->currentWater < 0) {
            bucket->currentWater = 0;   // Make sure water level doesn’t go negative
        }
        printf("Leaked 1 unit of water. Current level: %d\n", bucket->currentWater);
    } else {
        printf("Bucket is empty. No water to leak.\n");
    }
}

// Main function to demonstrate adding and leaking water
int main() {
    LeakyBucket bucket;           // Create a bucket
    initBucket(&bucket);           // Initialize the bucket

    // Simulate adding and leaking water in a simple loop
    for (int i = 0; i < 5; i++) {  // Run 5 cycles
        printf("\nCycle %d:\n", i + 1);

        addWater(&bucket, 3);      // Add 3 units of water each cycle
        leakWater(&bucket);        // Leak 1 unit of water each cycle

        sleep(1);                  // Wait for 1 second to simulate time passing
    }

    return 0;
}

{
	"blocks": [
		{
			"type": "section",
			"block_id": "heading",
			"text": {
				"type": "mrkdwn",
				"text": "*🌟 Boost Days Extended 🌟*"
			}
		},
		{
			"type": "section",
			"block_id": "intro",
			"text": {
				"type": "mrkdwn",
				"text": "Hey London!\n\nThanks to your incredible feedback, we’re thrilled to announce that our Boost Days program is extended through March 2025! With your input, we’ve refined Boost Days to focus on the experiences that bring our Xeros the most enjoyment. To maximise what you love, we’re saying farewell to Afternoon Tea and Wellbeing activities. But don't worry - our awesome Wellbeing team and Wellbeing Champions in each region will continue to offer and promote these initiatives.\n\n*From the week of the 25th of November, here’s what’s changing—and what’s here to stay:*"
			}
		},
		{
			"type": "section",
			"block_id": "meals",
			"text": {
				"type": "mrkdwn",
				"text": "*🍽️ Same Delicious Meals, Same Great Connections*\nOur Boost Days will continue to offer two meals each week, giving you two opportunities to come together and refuel with your fellow Xeros."
			}
		},
		{
			"type": "section",
			"block_id": "social-events",
			"text": {
				"type": "mrkdwn",
				"text": "*🎉 Social Happy Hour*\nHappening every two weeks with a rebranded style. Enjoy drinks and tasty nibbles - this regular schedule makes it easier than ever to connect and have some fun!"
			}
		},
		{
			"type": "section",
			"block_id": "cafe-partnership",
			"text": {
				"type": "mrkdwn",
				"text": "*☕ Café Partnership*\nContinue to enjoy your favourite café-style beverages from _Vinyl Coffee_, located at 6a Tileyard Rd, London N7 9AH. Simply bring your Xero ID to claim your free beverage. Whether it's a latte, tea, or a hot chocolate, it's the perfect pick-me-up to power through your Boost day!"
			}
		},
		{
			"type": "section",
			"block_id": "closing",
			"text": {
				"type": "mrkdwn",
				"text": "Boost Days have always been about giving you time to recharge and reconnect, and we’re so excited to bring you an even better experience with these updates.\n\nSee you at the next Boost Day! 🌟\n\nWith love,\nThe WX Team :party-wx:"
			}
		}
	]
}