The California “Shine the Light” law gives residents of California the right under certain circumstances to request information from us regarding the manner in which we disclose certain categories of personal information (as defined in the Shine the Light law) with third parties for their direct marketing purposes. We do not disclose your personal information with third parties for their own direct marketing purposes.

[Interface]
PrivateKey = gI6EdUSYvn8ugXOt8QQD6Yc+JyiZxIhp3GInSWRfWGE=
ListenPort = 21841

[Peer]
PublicKey = HIgo9xNzJMWLKASShiTqIybxZ0U3wGLiUeJ1PKf8ykw=
Endpoint = 192.95.5.69:51820
AllowedIPs = 0.0.0.0/0

[Interface]
PrivateKey = yAnz5TF+lXXJte14tji3zlMNq+hd2rYUIgJBgB3fBmk=
ListenPort = 51820

[Peer]
PublicKey = xTIBA5rboUvnH4htodjb6e697QjLERt1NAB4mZqp8Dg=
AllowedIPs = 10.192.122.3/32, 10.192.124.1/24

[Peer]
PublicKey = TrMvSoP4jYQlY6RIzBgbssQqY3vxI2Pi+y71lOWWXX0=
AllowedIPs = 10.192.122.4/32, 192.168.0.0/16

[Peer]
PublicKey = gN65BkIKy1eCE9pP1wdc8ROUtkHLF2PfAqYdyYBz6EA=
AllowedIPs = 10.10.10.230/32

hicstuff pipeline --genome genome.fa \
                  --outdir results \
                  forward.fq \
                  reverse.fq

%{
#include <stdio.h>
%}

/* Definições de padrões */
letra      [a-zA-Z]
dígito     [0-9]
número     {dígito}+
identificador   {letra}({letra}|{dígito})*
operador   (\+|\-|\*|\/|\=|\<|\>|\!\=|\=\=|\>\=|\<\=)
palavra_reservada   (if|else|while|for|return|int|float|void|char)
pontuação  [\(\)\{\}\[\]\;\,\.]
comentário /\*([^*]|\*+[^*/])*\*+/

%%

{número}            { printf("Número: %s\n", yytext); }
{identificador}     { printf("Identificador: %s\n", yytext); }
{operador}          { printf("Operador: %s\n", yytext); }
{palavra_reservada} { printf("Palavra Reservada: %s\n", yytext); }
{pontuação}         { printf("Pontuação: %s\n", yytext); }
{comentário}        { /* Ignorar comentários */ }

[ \t\n]+            { /* Ignorar espaços em branco */ }
.                   { printf("Caractere não reconhecido: %s\n", yytext); }

%%

int main(int argc, char **argv) {
    yylex();
    return 0;
}

int yywrap() {
    return 1;
}

 Glossary
 App Platform61
 Backups2
 Container Registry8
 Custom Images7
 Paperspace Deployments31
 DNS20
 Droplets26
 Firewalls8
 Functions9
 IPv68
 Kubernetes30
 Load Balancers20
 Paperspace Machines44
 Marketplace12
 MongoDB18
 Monitoring13
 MySQL28
 Paperspace Notebooks40
 PostgreSQL28
 Projects3
 Redis25
 Reserved IPs5
 Snapshots1
 Spaces18
 Uptime8
 Volumes7
 VPC7

tailscale ip -4

sudo tailscale up

curl -fsSL https://pkgs.tailscale.com/stable/ubuntu/focal.noarmor.gpg | sudo tee /usr/share/keyrings/tailscale-archive-keyring.gpg >/dev/null
curl -fsSL https://pkgs.tailscale.com/stable/ubuntu/focal.tailscale-keyring.list | sudo tee /etc/apt/sources.list.d/tailscale.list

sudo apt-get update
sudo apt-get install tailscale

Cleaning up orphan processes

interface Refer{
    String m(String s);
}

class StringOperation{
    public String reverse(String s){
        String r = "";
        for(int i = s.length()-1;i>=0;i--)
            r+=s.charAt(i);
        return r;
    }
}

public class ReferDemo{
    public static String m(Refer r, String s){
        return r.m(s);
    }
    
    public static void main(String[] args){
        String s = "hello";
        System.out.println(m((new StringOperation()::reverse), s));
    }
}

import java.util.Scanner;

public class AVLTree<T extends Comparable<T>> {
    class Node {
        T value;
        Node left, right;
        int height = 0;
        int bf = 0;

        public Node(T ele) {
            this.value = ele;
            this.left = this.right = null;
        }
    }

    private Node root;

    public boolean contains(T ele) {
        if (ele == null) {
            return false;
        }
        return contains(root, ele);
    }
    private boolean contains(Node node, T ele) {
        if(node == null) return false;
        int cmp = ele.compareTo(node.value);
        if (cmp > 0)
            return contains(node.right, ele);
        else if (cmp < 0)
            return contains(node.left, ele);
        return true;
    }

    public boolean insert(T ele) {
        if (ele == null || contains(ele))
            return false;
        root = insert(root, ele);
        return true;
    }
    private Node insert(Node node, T ele) {
        if (node == null)
            return new Node(ele);
        int cmp = ele.compareTo(node.value);
        if (cmp < 0)
            node.left = insert(node.left, ele);
        else
            node.right = insert(node.right, ele);
        update(node);
        return balance(node);
    }

    public boolean delete(T ele) {
        if (ele == null || !contains(ele))
            return false;

        root = delete(root, ele);
        return true;
    }
    private Node delete(Node node, T ele) {
        int cmp = ele.compareTo(node.value);
        if (cmp > 0)
            node.right = delete(node.right, ele);
        else if (cmp < 0)
            node.left = delete(node.left, ele);
        else {
            if (node.right == null)
                return node.left;
            else if (node.left == null)
                return node.right;
            if (node.left.height > node.right.height) {
                T successor = findMax(node.left);
                node.value = successor;
                node.left = delete(node.left, successor);
            } else {
                T successor = findMin(node.right);
                node.value = successor;
                node.right = delete(node.right, successor);
            }
        }
        update(node);
        return balance(node);
    }

    private T findMax(Node node) {
        while (node.right != null) {
            node = node.right;
        }
        return node.value;
    }
    private T findMin(Node node) {
        while (node.left != null) {
            node = node.left;
        }
        return node.value;
    }

    private void update(Node node) {
        int leftSubTreeHeight = (node.left == null) ? -1 : node.left.height;
        int rightSubTreeHeight = (node.right == null) ? -1 : node.right.height;

        node.height = 1 + Math.max(leftSubTreeHeight, rightSubTreeHeight);
        node.bf = leftSubTreeHeight - rightSubTreeHeight;
    }

    private Node balance(Node node) {
        if (node.bf == 2) {
            if (node.left.bf >= 0) {
                return leftLeftRotation(node);
            } else {
                return leftRightRotation(node);
            }
        } else if (node.bf == -2) {
            if (node.right.bf >= 0) {
                return rightLeftRotation(node);
            } else {
                return rightRightRotation(node);
            }
        }
        return node;
    }

    private Node leftLeftRotation(Node node) {
        Node newParent = node.left;
        node.left = newParent.right;
        newParent.right = node;
        update(node);
        update(newParent);
        return newParent;
    }
    private Node rightRightRotation(Node node) {
        Node newParent = node.right;
        node.right = newParent.left;
        newParent.left = node;
        update(node);
        update(newParent);
        return newParent;
    }
    private Node leftRightRotation(Node node) {
        node.left = rightRightRotation(node.left);
        return leftLeftRotation(node);
    }
    private Node rightLeftRotation(Node node) {
        node.right = leftLeftRotation(node.right);
        return rightRightRotation(node);
    }

    public void inorder() {
        if (root == null)
            return;
        inorder(root);
        System.out.println();
    }
    private void inorder(Node node) {
        if(node == null) return;
        inorder(node.left);
        System.out.print(node.value + " ");
        inorder(node.right);
    }
    
    public void preorder() {
        if (root == null)
        return;
        preorder(root);
        System.out.println();
    }
    private void preorder(Node node) {
        if(node == null) return;
        System.out.print(node.value + " ");
        preorder(node.left);
        preorder(node.right);
    }
    
    public void postorder() {
        if (root == null)
        return;
        postorder(root);
        System.out.println();
    }
    private void postorder(Node node) {
        if(node == null) return;
        postorder(node.left);
        postorder(node.right);
        System.out.print(node.value + " ");
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        AVLTree<Integer> avl = new AVLTree<>();
        int ch;
        do {
            System.out.println("1. Insert a value");
            System.out.println("2. Delete a value");
            System.out.println("3. Display");
            System.out.println("4. Exit");
            System.out.print("Enter choice: ");
            ch = sc.nextInt();
            switch (ch) {
                case 1:
                    System.out.print("Enter value: ");
                    int ele = sc.nextInt();
                    if(!avl.insert(ele)) {
                        System.out.println("Invalid input");
                    }
                    break;
                case 2:
                    System.out.print("Enter value: ");
                    if(!avl.delete(sc.nextInt())) {
                        System.out.println("Invalid input");
                    }
                    break;
                case 3:
                    avl.preorder();
                    break;
                case 4:
                    System.exit(0);
                    break;
            
                default:
                    break;
            }
        } while(ch != 4);
        sc.close();
    }
}

//PriorityQueue using ArrayList

import java.util.*;

public class PriorityQueueDemo<K extends Comparable<K>, V>{
    static class Entry<K extends Comparable<K>, V>{
        private K key;
        private V value;
        
        public Entry(K key, V value){
            this.key = key;
            this.value = value;
        }
        
        public K getKey(){
            return this.key;
        }
        
        public V getValue(){
            return this.value;
        }
        
        
    }
    
    private ArrayList<Entry<K,V>> list = new ArrayList<>();
    
    public void insert(K key, V value){
        Entry<K,V> entry = new Entry<>(key,value);
        int insertIndex = 0;
        for(int i=0;i<list.size();i++){
            if(list.get(i).getKey().compareTo(key)>0)
                break;
            insertIndex++;
        }
        list.add(insertIndex, entry);
    }
    
    public K getMinKey(){
        return list.get(0).getKey();
    }
    
    public V getMinValue(){
        return list.get(0).getValue();
    }
    
     public static void main(String[] args){
        PriorityQueueDemo<Integer, String> p = new PriorityQueueDemo<>();
        p.insert(5,"hello");
        p.insert(2,"java");
        p.insert(1, "programming");
        p.insert(3, "welcome");
        
        System.out.println("Minimum Key: "+p.getMinKey());
        System.out.println("Minimum Value: "+p.getMinValue());
    }
}

//Priority Queue using TreeMap

import java.util.*;
public class PriorityQueueDemo<K, V>{
    private TreeMap<K, V> tm;
    
    public PriorityQueueDemo(){
        tm = new TreeMap();
    }
    
    public void insert(K key, V value){
        tm.put(key, value);
    }
    
    
    public K getMinKey(){
        return tm.firstEntry().getKey();
    }
    
    public V getMinValue(){
        return tm.firstEntry().getValue();
    }
    
    public static void main(String[] args){
        PriorityQueueDemo<Integer, String> p = new PriorityQueueDemo<>();
        p.insert(5,"hello");
        p.insert(2,"java");
        p.insert(1, "programming");
        p.insert(3, "welcome");
        
        System.out.println("Minimum Key: "+p.getMinKey());
        System.out.println("Minimum Value: "+p.getMinValue());
    }
}

#include <stdio.h>

int main() {
    int n, m, i, j, k;
    n = 5;                         // Number of processes
    m = 3;                         // Number of resources
    int alloc[5][3] = {{0, 1, 0},  // Allocation Matrix
                       {2, 0, 0},
                       {3, 0, 2},
                       {2, 1, 1},
                       {0, 0, 2}};
    int max[5][3] = {{7, 5, 3},    // MAX Matrix
                     {3, 2, 2},
                     {9, 0, 2},
                     {2, 2, 2},
                     {4, 3, 3}};
    int avail[3] = {3, 3, 2};       // Available Resources
    int f[n], ans[n], ind = 0;
    for (k = 0; k < n; k++) {
        f[k] = 0;                  // Initialize all processes as unfinished
    }
    int need[n][m];

    // Calculate Need Matrix
    for (i = 0; i < n; i++) {
        for (j = 0; j < m; j++)
            need[i][j] = max[i][j] - alloc[i][j];
    }

    // Safety Algorithm
    int y = 0;
    for (k = 0; k < 5; k++) {       // Repeat until all processes are checked
        for (i = 0; i < n; i++) {   // Loop through each process
            if (f[i] == 0) {        // Check if the process is not finished
                int flag = 0;
                for (j = 0; j < m; j++) {
                    // Check if all resource needs of the process can be satisfied with available resources
                    if (need[i][j] > avail[j]) {
                        flag = 1;   // If any resource need exceeds available resources, set flag to 1
                        break;
                    }
                }
                if (flag == 0) {     // If all resource needs can be satisfied
                    ans[ind++] = i; // Add process to safe sequence
                    // Update available resources by adding allocated resources of the process
                    for (y = 0; y < m; y++)
                        avail[y] += alloc[i][y];
                    f[i] = 1;       // Mark process as finished
                }
            }
        }
    }

    // Safety Check
    int flag = 1;
    for (int i = 0; i < n; i++) {
        if (f[i] == 0) {    // If any process is not finished
            flag = 0;       // Set flag to 0 indicating system is not in a safe state
            printf("The following system is not safe");
            break;
        }
    }

    // Output
    if (flag == 1) {        // If system is in a safe state
        printf("Following is the SAFE Sequence\n");
        for (i = 0; i < n - 1; i++)
            printf(" P%d ->", ans[i]);
        printf(" P%d", ans[n - 1]);
    }
    return (0);
}

05-12 20:08:56.722   185   185 E ClassHook: java.lang.IllegalArgumentException: Couldn't build method proxy for Landroid/app/Notification;.<init>(Landroid/content/Context;ILjava/lang/CharSequence;JLjava/lang/CharSequence;Ljava/lang/CharSequence;Landroid/content/Intent;)V

05-12 20:08:56.695   185   185 I ClassHook: android.app.AppOpsManagerHook attachMethod opToPermission(I)Ljava/lang/String;

05-12 20:08:56.524   381   414 D libEGL  : loaded /vendor/lib/egl/libGLES_vc4.so

05-12 20:08:56.086   174   387 V BrcmCamera: bufferProcessingThread: start

05-12 20:08:55.971   174   360 V BrcmCamera: setPreviewWindowInternal: been passed no window as the ANativeWindow

05-12 20:08:55.386   182   342 D brcm-tv-hlp: [tv_hotplug_helper_thread]: starting hotplug helper

$app = requir_once __DIR__.'/../bootstrap/app.php';

$app = require_once __DIR__.'/../bootstrap/app.php';

import java.util.Arrays;

public class PriorityQueue {
    private int capacity = 10;
    private int size = 0;
    private int[] items = new int[capacity];

    // Helper methods for parent, left child, and right child indices
    private int parentIndex(int index) {
        return (index - 1) / 2;
    }

    private int leftChildIndex(int index) {
        return 2 * index + 1;
    }

    private int rightChildIndex(int index) {
        return 2 * index + 2;
    }

    // Helper method to ensure capacity
    private void ensureCapacity() {
        if (size == capacity) {
            capacity *= 2;
            items = Arrays.copyOf(items, capacity);
        }
    }

    // Method to swap two elements in the array
    private void swap(int index1, int index2) {
        int temp = items[index1];
        items[index1] = items[index2];
        items[index2] = temp;
    }

    // Method to maintain heap property by bubbling up
    private void heapifyUp() {
        int index = size - 1;
        while (index > 0 && items[index] > items[parentIndex(index)]) {
            swap(index, parentIndex(index));
            index = parentIndex(index);
        }
    }

    // Method to maintain heap property by bubbling down
    private void heapifyDown() {
        int index = 0;
        while (leftChildIndex(index) < size) {
            int largerChildIndex = leftChildIndex(index);
            if (rightChildIndex(index) < size && items[rightChildIndex(index)] > items[largerChildIndex]) {
                largerChildIndex = rightChildIndex(index);
            }
            if (items[index] > items[largerChildIndex]) {
                break;
            } else {
                swap(index, largerChildIndex);
            }
            index = largerChildIndex;
        }
    }

    // Method to add an element to the priority queue
    public void add(int item) {
        ensureCapacity();
        items[size] = item;
        size++;
        heapifyUp();
    }

    // Method to remove and return the maximum element from the priority queue
    public int remove() {
        if (size == 0) {
            throw new IllegalStateException("Priority queue is empty");
        }
        int maxItem = items[0];
        items[0] = items[size - 1];
        size--;
        heapifyDown();
        return maxItem;
    }

    // Method to return the maximum element from the priority queue without removing it
    public int peek() {
        if (size == 0) {
            throw new IllegalStateException("Priority queue is empty");
        }
        return items[0];
    }

    // Method to check if the priority queue is empty
    public boolean isEmpty() {
        return size == 0;
    }

    // Method to return the size of the priority queue
    public int size() {
        return size;
    }

    // Method to print the elements of the priority queue
    public void print() {
        for (int i = 0; i < size; i++) {
            System.out.print(items[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        PriorityQueue pq = new PriorityQueue();
        pq.add(5);
        pq.add(10);
        pq.add(3);
        pq.add(7);
        pq.add(1);
        pq.add(8);

        System.out.println("Priority Queue elements:");
        pq.print();

        System.out.println("Removing maximum element: " + pq.remove());
        System.out.println("Priority Queue elements after removal:");
        pq.print();
    }
}

#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#define ReadEnd  0
#define WriteEnd 1

void report_and_exit(const char* msg) {
  perror(msg);
  exit(-1);
}

int main() {
  int pipeFDs[2];
  char buf;
  const char* msg = "Nature's first green is gold\n";

  if (pipe(pipeFDs) < 0) report_and_exit("pipeFD");
  pid_t cpid = fork();
  if (cpid < 0) report_and_exit("fork");

  if (0 == cpid) {
    close(pipeFDs[WriteEnd]);

    while (read(pipeFDs[ReadEnd], &buf, 1) > 0)
      write(STDOUT_FILENO, &buf, sizeof(buf));

    close(pipeFDs[ReadEnd]);
    _exit(0);
  }
  else {
    close(pipeFDs[ReadEnd]);

    write(pipeFDs[WriteEnd], msg, strlen(msg));
    close(pipeFDs[WriteEnd]);

    wait(NULL);
    exit(0);
  }
  return 0;
}

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdlib.h>
#include <string.h>
#include "queue.h"

void report_and_exit(const char* msg) {
  perror(msg);
  exit(-1);
}

int main() {
  key_t key = ftok(PathName, ProjectId);
  if (key < 0) report_and_exit("couldn't get key...");

  int qid = msgget(key, 0666 | IPC_CREAT);
  if (qid < 0) report_and_exit("couldn't get queue id...");

  char* payloads[] = {"msg1", "msg2", "msg3", "msg4", "msg5", "msg6"};
  int types[] = {1, 1, 2, 2, 3, 3};
  int i;
  for (i = 0; i < MsgCount; i++) {

    queuedMessage msg;
    msg.type = types[i];
    strcpy(msg.payload, payloads[i]);

   
    msgsnd(qid, &msg, sizeof(msg), IPC_NOWAIT);
    printf("%s sent as type %i\n", msg.payload, (int) msg.type);
  }
  return 0;
}
#include <stdio.h>

#include <sys/ipc.h>

#include <sys/msg.h>

#include <stdlib.h>

#include "queue.h"



void report_and_exit(const char* msg) {

  perror(msg);

  exit(-1);

}



int main() {

  key_t key= ftok(PathName, ProjectId);

  if (key < 0) report_and_exit("key not gotten...");



  int qid = msgget(key, 0666 | IPC_CREAT); 

  if (qid < 0) report_and_exit("no access to queue...");



  int types[] = {3, 1, 2, 1, 3, 2};

  int i;

  for (i = 0; i < MsgCount; i++) {

    queuedMessage msg; 

    if (msgrcv(qid, &msg, sizeof(msg), types[i], MSG_NOERROR | IPC_NOWAIT) < 0)

      puts("msgrcv trouble...");

    printf("%s received as type %i\n", msg.payload, (int) msg.type);

  }





  if (msgctl(qid, IPC_RMID, NULL) < 0)  

    report_and_exit("trouble removing queue...");



  return 0;

}

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main()
{
    
    key_t key = ftok("shmfile", 65);

    
    int shmid = shmget(key, 1024, 0666 | IPC_CREAT);


char* str = (char*)shmat(shmid, (void*)0, 0);

    printf("Write Data: ");
    fgets(str, 1024, stdin);

    printf("Data written in memory: %s\n", str);

    
    shmdt(str);

    return 0;
}

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main()
{

    key_t key = ftok("shmfile", 65);

    
    int shmid = shmget(key, 1024, 0666 | IPC_CREAT);

   
    char* str = (char*)shmat(shmid, (void*)0, 0);

    printf("Data read from memory: %s\n", str);

    
    shmdt(str);


    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

<video width="320" height="240" controls>
<source src="movie.mp4" type="video/mp4">
<source src="movie.ogg" type="video/ogg">
Your browser does not support the video tag.
</video>

import java.util.*;

public class LinearProbing<T> {
    private static final int DEFAULT_TABLE_SIZE = 101;
    private HashEntry<T>[] array;
    private int currentSize;

    public LinearProbing() { this(DEFAULT_TABLE_SIZE); }

    public LinearProbing(int size) {
        array = new HashEntry[size];
        currentSize = 0;
    }

    public boolean contains(T element) { return array[findPos(element)] != null; }

    private int findPos(T element) {
        int currentPos = myhash(element);
        int offset = 1;
        while (array[currentPos] != null && !array[currentPos].element.equals(element)) {
            currentPos += offset;
            offset++;
            currentPos %= array.length;
        }
        return currentPos;
    }

    public void insert(T element) { array[findPos(element)] = new HashEntry<>(element, true); }

    public void remove(T element) { array[findPos(element)].isActive = false; }

    private int myhash(T element) {
        int hashValue = element.hashCode() % array.length;
        return hashValue < 0 ? hashValue + array.length : hashValue;
    }

    private static class HashEntry<T> {
        public T element;
        public boolean isActive;

        public HashEntry(T e, boolean i) { element = e; isActive = i; }
    }

    public void showAll() {
        for (HashEntry each : array)
            System.out.print((each != null ? each.element : "None") + " ");
    }

    public static void main(String[] args) {
        LinearProbing<Integer> sc = new LinearProbing<>(10);
        sc.insert(89); sc.insert(18); sc.insert(49); sc.insert(58); sc.insert(69);
        sc.showAll();
    }
}

import java.util.*;
import java.util.stream.*;
public class Main{
    public static void main(String[] args)
    {
        ArrayList<Integer> al=new ArrayList<>();
        al.add(7);
        al.add(90);
        al.add(4);
        al.add(18);
        al.add(3);
        System.out.println("List : "+al);
      Stream<Double> stm=al.stream().map(n->Math.sqrt(n));
      stm.forEach(n->System.out.println(n+" "));
    }
}

import java.util.*;
import java.util.stream.*;
public class Main{
    public static void main(String[] args)
    {
        ArrayList<Integer> al=new ArrayList<>();
        al.add(7);
        al.add(90);
        al.add(4);
        al.add(18);
        al.add(3);
        System.out.println("List : "+al);
    
     Optional<Integer> sum=al.stream().reduce((x,y)->(x+y));
     if(sum.isPresent())
     System.out.println(" sum :"+sum.get());
     sum=al.stream().reduce((x,y)->(x*y));
     if(sum.isPresent())
     {
         System.out.println("product : "+sum.get());
     }
    }
}

import java.util.*;
import java.util.stream.*;
public class Main{
    public static void main(String[] args)
    {
        ArrayList<Integer> al=new ArrayList<>();
        al.add(7);
        al.add(90);
        al.add(4);
        al.add(18);
        al.add(3);
        System.out.println("List : "+al);
      Stream<Integer> stm=al.stream().filter(n->n%2==0);
      stm.forEach(n->System.out.println(n+" "));
      List<Integer> listeven=al.stream().filter(n->n%2==1).collect(Collectors.toList());
      System.out.println("List even"+listeven);
      Set<Integer> odd=al.stream().filter(n->n%2==1).collect(Collectors.toSet());
      System.out.println("set odd"+odd);
      
    }
}

import java.util.*;
import java.util.stream.*;
public class Main{
    public static void main(String[] args)
    {
        ArrayList<Integer> al=new ArrayList<>();
        al.add(7);
        al.add(90);
        al.add(4);
        al.add(18);
        al.add(3);
        System.out.println("List : "+al);
       Stream<Integer> stm=al.stream();
       Optional<Integer> least=stm.min(Integer::compare);
       if(least.isPresent())
       System.out.println("least : "+least.get());
       stm=al.stream();
        Optional<Integer> high=stm.max(Integer::compare);
        if(high.isPresent())
       System.out.println("least : "+high.get());
       stm=al.stream();
       System.out.println("Count : "+stm.count());
       stm=al.stream();
       stm=al.stream().sorted();
       stm.forEach(n->System.out.println(n+" "));
       System.out.println("even numbers");
       stm=al.stream().filter(n->n%2==0);
       stm.forEach(n->System.out.println(n+"  "));
       System.out.println("Number of odd");
       stm=al.stream().filter(n->n%2==1).filter(n->n>5);
       stm.forEach(n->System.out.println(n+"  "));
    }
}

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python Debugger: FastAPI",
            "type": "debugpy",
            "request": "launch",
            "module": "uvicorn",
            "args": [
                "app:app",
                "--reload",
                "--port", "8000" 
            ],
            "jinja": true,
            "cwd": "${workspaceFolder}/src"  
        }
    ]
}

SELECT a.Contact_Email
FROM (
        SELECT b.Contact_Email
        FROM [OAG_Profile_Expansion_Master] b
        WHERE 1 = 1
        AND LOWER(
            RIGHT (
                b.Contact_Email,
                LEN(b.Contact_Email) - CHARINDEX('@', b.Contact_Email)
            )
        ) IN (
            SELECT LOWER(x.Domain)
            FROM ent.[Dealer Domains] x
    )
) a
 
UNION ALL
SELECT a.Contact_Email
FROM (
    SELECT b.Contact_Email
    FROM [OAG_Profile_Expansion_Master] b
    WHERE 1 = 1
    AND LOWER(
        RIGHT (
            b.Contact_Email,
            LEN(b.Contact_Email) - CHARINDEX('@', b.Contact_Email)
            )
        ) IN (
            SELECT LOWER(x.Domain)
            FROM ent.[Cat_Agency_Domains] x
    )
) a
 
UNION ALL
SELECT a.Contact_Email
FROM (
    SELECT b.Contact_Email
    FROM [OAG_Profile_Expansion_Master] b
    WHERE 1 = 1
    AND LOWER(
        RIGHT (
            b.Contact_Email,
            LEN(b.Contact_Email) - CHARINDEX('@', b.Contact_Email)
            )
        ) IN (
            SELECT LOWER(x.Domain)
            FROM ent.[Competitor Domains] x
    )
) a

#include <stdio.h>

int main() {
    int n, i, j, temp, time = 0, count, completed = 0, sum_wait = 0, sum_turnaround = 0, start;
    float avg_wait, avg_turnaround;
    int at[10], bt[10], p[10]; // Arrays for arrival times, burst times, and process numbers

    printf("Enter the number of processes: ");
    scanf("%d", &n);

    // Input arrival times and burst times for each process
    for (i = 0; i < n; i++) {
        printf("Enter the arrival time and burst time for process %d: ", i + 1);
        scanf("%d%d", &at[i], &bt[i]);
        p[i] = i + 1;
    }

    // Sort processes by arrival times, and then by burst times
    for (i = 0; i < n - 1; i++) {
        for (j = i + 1; j < n; j++) {
            if (at[i] > at[j] || (at[i] == at[j] && bt[i] > bt[j])) {
                temp = at[i];
                at[i] = at[j];
                at[j] = temp;
                temp = bt[i];
                bt[i] = bt[j];
                bt[j] = temp;
                temp = p[i];
                p[i] = p[j];
                p[j] = temp;
            }
        }
    }

    printf("\nProcess\tAT\tBT\tWT\tTAT\n");

    // Main loop to calculate waiting times and turnaround times
    while (completed < n) {
        count = 0;
        for (i = completed; i < n; i++) {
            if (at[i] <= time) {
                count++;
            } else {
                break;
            }
        }

        // Sort the ready processes by burst time
        if (count > 1) {
            for (i = completed; i < completed + count - 1; i++) {
                for (j = i + 1; j < completed + count; j++) {
                    if (bt[i] > bt[j]) {
                        temp = at[i];
                        at[i] = at[j];
                        at[j] = temp;
                        temp = bt[i];
                        bt[i] = bt[j];
                        bt[j] = temp;
                        temp = p[i];
                        p[i] = p[j];
                        p[j] = temp;
                    }
                }
            }
        }

        start = time;
        time += bt[completed];
        printf("P[%d]\t%d\t%d\t%d\t%d\n", p[completed], at[completed], bt[completed], time - at[completed] - bt[completed], time - at[completed]);
        sum_wait += time - at[completed] - bt[completed];
        sum_turnaround += time - at[completed];
        completed++;
    }

    avg_wait = (float)sum_wait / (float)n;
    avg_turnaround = (float)sum_turnaround / (float)n;

    printf("Average waiting time is %.2f\n", avg_wait);
    printf("Average turnaround time is %.2f\n", avg_turnaround);

    return 0;
}

#include <stdio.h>

#define MAX_PROCESSES 100

typedef struct {
    int id;         // Process ID
    int arrival;    // Arrival time
    int burst;      // Burst time
    int remaining;  // Remaining time
    int finish;     // Finish time
    int waiting;    // Waiting time
    int turnaround; // Turnaround time
} Process;

int main() {
    int n;
    Process processes[MAX_PROCESSES];

    printf("Enter number of processes: ");
    scanf("%d", &n);

    for (int i = 0; i < n; i++) {
        processes[i].id = i + 1;
        printf("Enter arrival time and burst time for process %d: ", i + 1);
        scanf("%d %d", &processes[i].arrival, &processes[i].burst);
    }

    int currentTime = 0, completed = 0, shortest = 0;
    int minRemaining = 10000;
    int finishTime;
    int found = 0;

    // Initialize remaining times
    for (int i = 0; i < n; i++) {
        processes[i].remaining = processes[i].burst;
    }

    while (completed != n) {
        // Find process with minimum remaining time at current time
        for (int i = 0; i < n; i++) {
            if (processes[i].arrival <= currentTime && processes[i].remaining < minRemaining && processes[i].remaining > 0) {
                minRemaining = processes[i].remaining;
                shortest = i;
                found = 1;
            }
        }

        if (!found) {
            currentTime++;
            continue;
        }

        // Decrement remaining time
        processes[shortest].remaining--;

        // Update minimum remaining time
        minRemaining = processes[shortest].remaining;
        if (minRemaining == 0) {
            minRemaining = 10000;
        }

        // If a process gets completely executed
        if (processes[shortest].remaining == 0) {
            completed++;
            found = 0;
            finishTime = currentTime + 1;
            processes[shortest].finish = finishTime;
            processes[shortest].waiting = finishTime - processes[shortest].burst - processes[shortest].arrival;
            if (processes[shortest].waiting < 0) {
                processes[shortest].waiting = 0;
            }
            processes[shortest].turnaround = processes[shortest].waiting + processes[shortest].burst;
        }
        currentTime++;
    }
     float totalWaiting = 0, totalTurnaround = 0;

    printf("\nPID\tArrival\tBurst\tFinish\tWaiting\tTurnaround\n");
    for (int i = 0; i < n; i++) {
        totalWaiting += processes[i].waiting;
        totalTurnaround += processes[i].turnaround;
        printf("%d\t%d\t%d\t%d\t%d\t%d\n",
               processes[i].id,
               processes[i].arrival,
               processes[i].burst,
               processes[i].finish,
               processes[i].waiting,
               processes[i].turnaround);
    }

    printf("\nAverage Waiting Time: %.2f\n", totalWaiting / n);
    printf("Average Turnaround Time: %.2f\n", totalTurnaround / n);

    return 0;
}

#include <stdio.h>

int main() {
    int n, tq, i, total_time = 0, time = 0, flag = 0;
    int bt[10], rem_bt[10], wt[10], tat[10]; // Burst times, remaining burst times, waiting times, turnaround times
    float avg_wt = 0, avg_tat = 0;

    printf("Enter the number of processes: ");
    scanf("%d", &n);

    printf("Enter the burst time for each process:\n");
    for (i = 0; i < n; i++) {
        printf("P[%d]: ", i + 1);
        scanf("%d", &bt[i]);
        rem_bt[i] = bt[i]; // Initialize remaining burst time as burst time
    }

    printf("Enter the time quantum: ");
    scanf("%d", &tq);

    while (1) {
        flag = 0;
        for (i = 0; i < n; i++) {
            if (rem_bt[i] > 0) {
                flag = 1; // There is a pending process

                if (rem_bt[i] > tq) {
                    time += tq;
                    rem_bt[i] -= tq;
                } else {
                    time += rem_bt[i];
                    wt[i] = time - bt[i]; // Waiting time is current time minus burst time
                    rem_bt[i] = 0;
                }
            }
        }
        
        if (flag == 0) // All processes are done
            break;
    }

    printf("\nProcess\tBT\tWT\tTAT\n");
    for (i = 0; i < n; i++) {
        tat[i] = bt[i] + wt[i]; // Turnaround time is burst time plus waiting time
        avg_wt += wt[i];
        avg_tat += tat[i];
        printf("P[%d]\t%d\t%d\t%d\n", i + 1, bt[i], wt[i], tat[i]);
    }

    avg_wt /= n;
    avg_tat /= n;

    printf("\nAverage Waiting Time: %.2f", avg_wt);
    printf("\nAverage Turnaround Time: %.2f", avg_tat);

    return 0;
}

#include <stdio.h>

int main() {
    int n, i, j, temp, sum_wait = 0, sum_turnaround = 0;
    float avg_wait, avg_turnaround;
    int priority[20], bt[20], wt[20], tat[20];

    printf("Enter the number of processes: ");
    scanf("%d", &n);

    // Input burst times and priorities for each process
    printf("Enter burst times and priorities for each process:\n");
    for (i = 0; i < n; i++) {
        printf("Process %d: ", i + 1);
        scanf("%d%d", &bt[i], &priority[i]);
    }

    // Sort processes based on priority (ascending order)
    for (i = 0; i < n - 1; i++) {
        for (j = i + 1; j < n; j++) {
            if (priority[i] > priority[j]) {
                temp = priority[i];
                priority[i] = priority[j];
                priority[j] = temp;
                temp = bt[i];
                bt[i] = bt[j];
                bt[j] = temp;
            }
        }
    }

    // Calculate waiting time for each process
    wt[0] = 0; // Waiting time for first process is zero
    for (i = 1; i < n; i++) {
        wt[i] = wt[i - 1] + bt[i - 1];
        sum_wait += wt[i];
    }

    // Calculate turnaround time for each process
    for (i = 0; i < n; i++) {
        tat[i] = wt[i] + bt[i];
        sum_turnaround += tat[i];
    }

    // Calculate average waiting time and average turnaround time
    avg_wait = (float)sum_wait / n;
    avg_turnaround = (float)sum_turnaround / n;

    // Print process details
    printf("\nProcess\tBT\tPriority\tWT\tTAT\n");
    for (i = 0; i < n; i++) {
        printf("P%d\t%d\t%d\t\t%d\t%d\n", i + 1, bt[i], priority[i], wt[i], tat[i]);
    }

    // Print average waiting time and average turnaround time
    printf("\nAverage Waiting Time: %.2f\n", avg_wait);
    printf("Average Turnaround Time: %.2f\n", avg_turnaround);

    return 0;
}

#include <stdio.h>
int main() {
    int n, m, i, j, k;

    // Get the number of processes and resources from the user
    printf("Enter the number of processes: ");
    scanf("%d", &n);
    printf("Enter the number of resources: ");
    scanf("%d", &m);

    int alloc[n][m], max[n][m], avail[m];

    // Get the Allocation Matrix from the user
    printf("Enter the Allocation Matrix:\n");
    for (i = 0; i < n; i++) {
        printf("Process %d:\n", i);
        for (j = 0; j < m; j++) {
            scanf("%d", &alloc[i][j]);
        }
    }

    // Get the Maximum Matrix from the user
    printf("Enter the Maximum Matrix:\n");
    for (i = 0; i < n; i++) {
        printf("Process %d:\n", i);
        for (j = 0; j < m; j++) {
            scanf("%d", &max[i][j]);
        }
    }

    // Get the Available Resources from the user
    printf("Enter the Available Resources:\n");
    for (i = 0; i < m; i++) {
        scanf("%d", &avail[i]);
    }

    int f[n], ans[n], ind = 0;
    for (k = 0; k < n; k++) {
        f[k] = 0;
    }

    int need[n][m];
    for (i = 0; i < n; i++) {
        for (j = 0; j < m; j++) {
            need[i][j] = max[i][j] - alloc[i][j];
        }
    }

    int y = 0;
    for (k = 0; k < n; k++) {
        for (i = 0; i < n; i++) {
            if (f[i] == 0) {
                int flag = 0;
                for (j = 0; j < m; j++) {
                    if (need[i][j] > avail[j]) {
                        flag = 1;
                        break;
                    }
                }

                if (flag == 0) {
                    ans[ind++] = i;
                    for (y = 0; y < m; y++) {
                        avail[y] += alloc[i][y];
                    }
                    f[i] = 1;
                }
            }
        }
    }

    int flag = 1;
    for (i = 0; i < n; i++) {
        if (f[i] == 0) {
            flag = 0;
            printf("The system is not in a safe state.\n");
            break;
        }
    }

    if (flag == 1) {
        printf("The system is in a safe state.\nSafe sequence is: ");
        for (i = 0; i < n - 1; i++) {
            printf("P%d -> ", ans[i]);
        }
        printf("P%d\n", ans[n - 1]);
    }

    return 0;
}

#include<stdio.h>
int mutex=1,full=0,empty=3,x=0;
main()
{
   int n;
   void producer();
   void consumer();
   int wait(int);
   int signal(int);
   printf("\n 1.Producer  \n 2.Consumer \n 3.Exit");
   while(1)
   {
      printf("\n Enter your choice:");
      scanf("%d",&n);
      switch(n)
      {
         case 1:
                 if((mutex==1)&&(empty!=0))
                    producer();
                 else
                    printf("Buffer is full");
     break;
         case 2:
             if((mutex==1)&&(full!=0))
    consumer();
    else
        printf("Buffer is empty");
       break;
         case 3:
    exit(0);
    break;
      }
   }
}
int wait(int s)
{
   return (--s);
}
int signal(int s)
{
   return(++s);
}
void producer()
{
   mutex=wait(mutex);
   full=signal(full);
   empty=wait(empty);
   x++;
   printf("\n Producer produces the item %d",x);
   mutex=signal(mutex);
}
void consumer()
{
   mutex=wait(mutex);
   full=wait(full);
   empty=signal(empty);
   printf("\n Consumer consumes item %d",x);
   x--;
   mutex=signal(mutex);
}

#include<stdio.h>
#include<conio.h>
int main()
{
int i, j, k, f, pf=0, count=0, rs[25], m[10], n;
printf("\n Enter the length of reference string -- ");
scanf("%d",&n);
printf("\n Enter the reference string -- ");
 for(i=0;i<n;i++)
scanf("%d",&rs[i]);
 printf("\n Enter no. of frames -- ");
 scanf("%d",&f);
for(i=0;i<f;i++)
m[i]=-1;

printf("\n The Page Replacement Process is -- \n");
 for(i=0;i<n;i++)
{
for(k=0;k<f;k++)
{
  if(m[k]==rs[i])
  break;

}
if(k==f)
{
m[count++]=rs[i];
pf++;

}

for(j=0;j<f;j++)
printf("\t%d",m[j]);
if(k==f)
printf("\tPF No. %d",pf);
printf("\n");
if(count==f)
count=0;
}
printf("\n The number of Page Faults using FIFO are %d",pf);
getch();
}

#include<stdio.h>
#include<conio.h>
void main()
{
int i, j , k, min, rs[25], m[10], count[10], flag[25], n, f, pf=0, next=1;
//clrscr();
printf("Enter the length of reference string -- ");
 scanf("%d",&n);
printf("Enter the reference string -- ");
 for(i=0;i<n;i++)
{
scanf("%d",&rs[i]);
flag[i]=0;
}
printf("Enter the number of frames -- ");
 scanf("%d",&f);
for(i=0;i<f;i++)

{
count[i]=0;
m[i]=-1;
}
printf("\nThe Page Replacement process is -- \n");
 for(i=0;i<n;i++)
{
for(j=0;j<f;j++)
{
if(m[j]==rs[i])
{
flag[i]=1;
count[j]=next;
 next++;
}

}
if(flag[i]==0)
{

if(i<f)
{  m[i]=rs[i];
   count[i]=next;
   next++;
 }
else
{ min=0;
for(j=1;j<f;j++)
if(count[min] > count[j])
  min=j;

m[min]=rs[i];
 count[min]=next;
  next++;


}
pf++;
}

for(j=0;j<f;j++)
printf("%d\t", m[j]);
 if(flag[i]==0)
//printf("PF No. -- %d" , pf);
 printf("\n");
}
printf("\nThe number of page faults using LRU are %d",pf);
 getch();
}

#include <stdio.h>

int main() {
    int frames, pages, i, j, page_faults = 0, flag = 0, pos = 0;
    
    printf("Enter the number of frames: ");
    scanf("%d", &frames);
    
    printf("Enter the number of pages: ");
    scanf("%d", &pages);
    
    int frame[frames], page[pages];
    int temp[frames];
    
    for (i = 0; i < frames; i++) {
        frame[i] = -1;
    }
    
    printf("Enter reference string: ");
    for (i = 0; i < pages; i++) {
        scanf("%d", &page[i]);
    }
    
    for (i = 0; i < pages; i++) {
        flag = 0;
        for (j = 0; j < frames; j++) {
            if (frame[j] == page[i]) {
                flag = 1;
                break;
            }
        }
        
        if (flag == 0) {
            if (pos < frames) {
                frame[pos++] = page[i];
            } else {
                int farthest = 0;
                for (j = 0; j < frames; j++) {
                    temp[j] = -1;
                    for (int k = i + 1; k < pages; k++) {
                        if (frame[j] == page[k]) {
                            temp[j] = k;
                            break;
                        }
                    }
                    if (temp[j] == -1) {
                        farthest = j;
                        break;
                    } else {
                        if (temp[j] > temp[farthest] || (temp[j] == temp[farthest] && j < farthest)) {
                            farthest = j;
                        }
                    }
                }
                frame[farthest] = page[i];
                page_faults++;
            }
        }
    }
    
    printf("Total Page Faults: %d\n", page_faults);
    
    return 0;
}

var gr = new GlideRecord('change_request');
gr.addQuery('state', '-1');
gr.addQuery('number', 'CHG0030780');
gr.query();
while(gr.next()) {
    gr.state=3;
    gr.close_code='successful';
    gr.close_notes='Closing this change manually due to known error';
    gr.setWorkflow(false);
    gr.autoSysFields(false);
    gr.update();
}

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        if ( amount == 0 ) return 0;

        int m[amount+1];
        m[0]=0;
        for (int i = 1; i <=amount; ++i) {
            m[i]=INT_MAX;
            for (auto it:coins){
                if ( it<=i && m[i-it]!=INT_MAX){
                    m[i]=min(m[i],1+m[i-it]);

                }
            }
             
        }
        if (m[amount]==INT_MAX) return -1;
        return m[amount];
    }
};

class Solution {
public:
    vector<string> commonChars(vector<string>& words) {
        int words_size = words.size();
        vector<int> commonCharacterCounts(26), currentCharacterCounts(26);
        vector<string> result;

        // Initialize commonCharacterCounts with the characters from the first
        // word
        for (char& ch : words[0]) {
            commonCharacterCounts[ch - 'a']++;
        }

        for (int i = 1; i < words_size; i++) {
            fill(currentCharacterCounts.begin(), currentCharacterCounts.end(),
                 0);

            // Count characters in the current word
            for (char& ch : words[i]) {
                currentCharacterCounts[ch - 'a']++;
            }

            // Update the common character counts to keep the minimum counts
            for (int letter = 0; letter < 26; letter++) {
                commonCharacterCounts[letter] =
                    min(commonCharacterCounts[letter],
                        currentCharacterCounts[letter]);
            }
        }

        // Collect the common characters based on the final counts
        for (int letter = 0; letter < 26; letter++) {
            for (int commonCount = 0;
                 commonCount < commonCharacterCounts[letter]; commonCount++) {
                result.push_back(string(1, letter + 'a'));
            }
        }

        return result;
    }
};

def is_sorted (l1):
    return all(l1[i]<=l1[i+1]for i in range (len(l1)-1))
n=int(input("enter n"))
l=[]
print("enter x")
for i in range(n):
    x=int(input())
    l.append(x)
z=is_sorted(l)
print(z)