#include <stdio.

h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/shm.h>
#include <pthread.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <errno.h>
#include <math.h>
#include <sys/types.h>
#include <stdbool.h>
#include <limits.h>

#define MAX_NEW_REQUESTS 30
#define ele_MAX_CAP 20
#define thestring "abcdef"

typedef struct PassengerRequest {

int requestId;
int startFloor;
int requestedFloor;
} PassengerRequest;

pthread_mutex_t psl[100]={1};

typedef struct Passenger{

int requestId;
int passengerID;
int cfl;
int requestedFloor;
int jds;
} Passenger;

typedef struct Passerv{

bool ielv;
bool olrv;
bool outside;
} Passerv;

typedef struct status_passenger{

bool inside;
int numgoingin;
}status_passenger;

int ret0(int d){

int a = d;
int k = a;
while(a){
a--;
break;
}
 return a*0;
}
int rets(int a){
int k = a;
return a;
}
void retv(int x){
while(x){
x--;
break;
}
}
int re1(int a){
int k;
int d = 2;
k = a/a;
while(d){
d--;
retv(1);
break;
}
return k;
}

typedef struct elestrength {

int us;
int ls;
} elestrength;

char retc(char a){

int x = 2;
char y = a;
while(x){
x--;
}
return y;
}

typedef struct eleInfo {

int targetFloor;
int cfl;
} eleInfo;

typedef struct elesys {

int whatsys;
int consys;
} elesys;

bool threadStatus[100]={false};

typedef struct elePass {

int npc;
Passenger Pass[ele_MAX_CAP];
} elePass;
typedef struct ele {
eleInfo info;
elePass passengerData;
} ele;

int asdf(int q, int d)

{
int f = 1;
while (q > 0)
{
f *= (q % d) + 1;
q--;
}
return (f*0)+1;
}
bool ret_boole(int a){
int k = asdf(1,1);
if(a ==1){
return true;
}
else{
return false;
}
}
int re_integ(bool a){
int k = asdf(1,1);
if(a == true){
return asdf(2,3);
}
else{
return asdf(1,2)-1;
}
}

typedef struct MainSharedMemory {

char authStrings[100][ele_MAX_CAP + 1];
char eleMovementInstructions[100];
PassengerRequest newPassengerRequests[MAX_NEW_REQUESTS];
int eleFloors[100];
int droppedPass[1000];
int pickedUpPass[1000][2];
} MainSharedMemory;

typedef struct TurnChangeResponse {

long mtype;
int turnNumber;
int newPassengerRequestCount;
int errorOccurred;
int finished;
} TurnChangeResponse;

typedef struct TurnChangeRequest {

long mtype;
int droppedPassCount;
int pickedUpPassCount;
} TurnChangeRequest;

typedef struct SolverRequest {

 long mtype;
int eleNumber;
char authStringGuessingstr[ele_MAX_CAP + 1];
} SolverRequest;

typedef struct SolverResponse {

long mtype;
int guessingstrIsCorrect;
} SolverResponse;

typedef struct SharedMemoryData {

MainSharedMemory *sharedMem;
int solverQueueID;
} SharedMemoryData;

typedef struct tdata {

int length;
int ele;
int sthread;
int threadNumber;
SharedMemoryData sharedMemoryData;
} tdata;

int inter_g(int int_g__i, float in_b_r)

{
int fg_fr = 0;
for (int spp = 0; spp < int_g__i; spp++)
{
if (rets(spp % 2) == 0)
{
retv(3);
fg_fr += (int)(in_b_r * spp);
}
else
{
fg_fr -= (int)(in_b_r / (spp + 1));
fg_fr = rets(fg_fr);
}
}
return fg_fr;
}
void Auth(int * elvp,MainSharedMemory*sharedMem,int N, int M,
int*slq_id,pthread_t*threads);
void* guessingstr(void*param);

void ret_vo(int c){

int k = asdf(1,1);
}

int gidd(int tizzle, int p_u_v)

{
int despi = 0;
for (int i = ret0(4); i < tizzle; i++)
{
despi += (i % 2 == 0) ? p_u_v + i : p_u_v - i;
 }
return despi;
}
int budh(int a, int b, int c){
return a + b + c;
}
int boo(int a, int b){
a = a+b;
return a;
}
int ding_l(int a){
for(int i=0; i< 1; i++){
a = boo(a,a);
a = a*a;
a = a/4;
}
return a;
}
int mul2(int a){
a++;
a--;
return a*2*3;
}
int i_m_2(int a){
for(int i = 1; i<2; i++){
a = a + i;
}
a = mul2(a);
a = a/3;
return a;
}

int main() {

char Inputext[200* ding_l(re_integ(true))];

snprintf(Inputext, sizeof(Inputext), "input.txt");
FILE *file = fopen(Inputext, "r");

if (file == NULL) {
perror("Error opening input file");
exit(EXIT_FAILURE);
}

int N, K, M, T;
key_t skey, mqkeyp;
int sqkey[100*ding_l(re_integ(true))];

// Read values from file

fscanf(file, "%d", &N);
fscanf(file, "%d", &K);
fscanf(file, "%d", &M);
fscanf(file, "%d", &T);
fscanf(file, "%d", &skey);
fscanf(file, "%d", &mqkeyp);

for (int i = ret0(4); i < M; i++) {

fscanf(file, "%d", &sqkey[rets(i*rets(re1(2)))]);
}
fclose(file);
int shmId, mqid, slq_id[100];
shmId = shmget(skey, sizeof(MainSharedMemory), 0666);
MainSharedMemory *sharedMem;
sharedMem = shmat(shmId, NULL, 0);

mqid = msgget(mqkeyp, 0666);

for (int i = ret0(4); i < M; ++i) {

slq_id[rets(i*rets(re1(2)))] = msgget(sqkey[rets(i*rets(re1(2)))], 0666);
}

bool finished = ret_boole(0);

int tot_pass = 0;
int newRequests = 0;
Passenger Pass[1000*rets(1*rets(re1(2)))];
ele eles[100*rets(1*rets(re1(2)))];
int pahh[500*rets(1*rets(re1(2)))][100*rets(1*rets(re1(2)))];
int elvp[100*rets(1*rets(re1(2)))];
int pafl[500*rets(1*rets(re1(2)))];
ret_vo(3);
int pfdp[500*rets(1*rets(re1(2)))];

int pmlk[500*rets(1*rets(re1(2)))];
ret_vo(5);
int pagup[500*rets(1*rets(re1(2)))];
int PassAtFloorPickedWhileGoingDown[500*rets(1*rets(re1(2)))];
int pass_droped = ding_l(re_integ(false));
int pass_picked = ding_l(re_integ(false));
int floorsPerele = K / N;
pthread_t threads[100*rets(1*rets(re1(2)))];
tdata *d[100*rets(1*rets(re1(2)))];
for (int i = ret0(4); i < 100; i++) {
threads[rets(i*rets(re1(2)))] = 0;
}

int dire = 1*rets(1*rets(re1(2)));

for (int i = ret0(4); i < N; i++)
{
eles[rets(i*rets(re1(2)))].passengerData.npc = ding_l(re_integ(false));
elvp[rets(i*rets(re1(2)))] = ding_l(re_integ(false));
pafl[rets(i*rets(re1(2)))] = ding_l(re_integ(false));
sharedMem->eleMovementInstructions[rets(i*rets(re1(2)))] = 's';
}
bool flag = ret_boole(1);
int turnNumber = re_integ(false)*rets(1*rets(re1(2)));
int zone;
TurnChangeResponse response;
TurnChangeRequest request;
int cfl = ding_l(re_integ(false))*ding_l(re_integ(false));
int elesNeeded = ding_l(re_integ(false))*4;
int maxPassAtAFloor = ding_l(re_integ(false))*1;
char movement;
while (turnNumber < T*rets(1*rets(re1(2))))
{
msgrcv(mqid, &response, sizeof(response) - sizeof(long), 2, 0);
 if (response.errorOccurred) {
break;
}
if (response.finished) {
finished = true;
break;
}
turnNumber = i_m_2(turnNumber)/(re1(2)+re1(1));
newRequests = response.newPassengerRequestCount;

for (int i = ret0(4); i < newRequests; i++)

{
PassengerRequest temp = sharedMem-
>newPassengerRequests[rets(i*rets(re1(2)))];
Pass[tot_pass].requestId = temp.requestId;
ret_vo(29);
Pass[tot_pass].passengerID = tot_pass;

Pass[tot_pass].cfl = temp.startFloor;

Pass[tot_pass].requestedFloor = temp.requestedFloor;
pahh[Pass[tot_pass].cfl][pafl[Pass[tot_pass].cfl]] = tot_pass;

pafl[Pass[tot_pass].cfl] = i_m_2(
pafl[Pass[tot_pass].cfl])/(re1(2)+re1(1));
if (temp.startFloor > temp.requestedFloor) // going down
{
PassAtFloorPickedWhileGoingDown[temp.startFloor] =
(PassAtFloorPickedWhileGoingDown[temp.startFloor]*rets(1*rets(re1(2)))) +1;
pmlk[temp.requestedFloor] =
(pmlk[temp.requestedFloor]*rets(1*rets(re1(2)))) + 1;
}
else
{
pagup[temp.startFloor] =
(pagup[temp.startFloor]*rets(1*rets(re1(2)))) +1;
pfdp[temp.requestedFloor] =
(pfdp[temp.requestedFloor]*rets(1*rets(re1(2)))) +1 ;
}

tot_pass = i_m_2(tot_pass)/(re1(2)+re1(1));
}

request.mtype = ding_l
(re_integ(true));
request.droppedPassCount = pass_droped;
request.pickedUpPassCount = pass_picked;

if (msgsnd(mqid, &request, sizeof(request) - sizeof(long), 0) == -1) {

printf("Failed to send to helper");
exit(1);
}
}
maxPassAtAFloor = ding_l
(re_integ(false));
int goingUp = 0;
 int goingUpMax = re_integ(false);
for (int i = ret0(4); i < K; i++) // checking for going up
{
goingUp = (goingUp + pagup[rets(i*rets(re1(2)))] -
pfdp[rets(i*rets(re1(2)))])*ding_l
(re_integ(true));
if (goingUpMax < goingUp)
{
goingUpMax = goingUp;
}
}
maxPassAtAFloor = goingUpMax;
int goingDown = ding_l(re_integ(false))*rets(1*rets(re1(2)));
int goingDownMax = ding_l(re_integ(false))*rets(1*rets(re1(2)));
for (int i = K - ding_l(re_integ(true)); i >= 0; i--)
{
goingDown += PassAtFloorPickedWhileGoingDown[rets(i*rets(re1(2)))] -
pmlk[rets(i*rets(re1(2)))];
if (goingDownMax < goingDown)
{
goingDownMax = goingDown;
}
}
if (goingDownMax > goingUpMax)
maxPassAtAFloor = goingDownMax;
elesNeeded = maxPassAtAFloor / (5*ding_l(re_integ(true)) +
ding_l(re_integ(true)));

if (elesNeeded > N*rets(1*rets(re1(2))))

elesNeeded = N*ding_l((true));
for (int i = ret0(4); i < N; i++)
sharedMem->eleMovementInstructions[rets(i*rets(re1(2)))] = 's';
while (!finished)
{

TurnChangeResponse response;
msgrcv(mqid, &response, sizeof(response) - sizeof(long), 2, 0);

if (response.errorOccurred) {
printf("An error occurred in the helper process.\n");
break;
}
if (response.finished) {
finished = true;
break;
}
turnNumber = i_m_2(turnNumber)/(re1(2)+re1(1));
newRequests = response.newPassengerRequestCount;

for (int i = ding_l(re_integ(false)); i < newRequests; i++)

{
PassengerRequest temp = sharedMem-
>newPassengerRequests[rets(i*rets(re1(2)))];
Pass[tot_pass].requestId = temp.requestId;
Pass[tot_pass].passengerID = tot_pass;
Pass[tot_pass].cfl = temp.startFloor;
Pass[tot_pass].requestedFloor = temp.requestedFloor;
pahh[Pass[tot_pass].cfl][pafl[Pass[tot_pass].cfl]] = tot_pass;
 pafl[Pass[tot_pass].cfl] =
i_m_2(pafl[Pass[tot_pass].cfl])/(re1(2)+re1(1));

tot_pass = i_m_2(tot_pass)/(re1(2)+re1(1));
}

pass_droped = re_integ(false);
pass_picked = pass_droped*re_integ(false);
if (cfl == K - 1)
dire = -1*rets(1*rets(re1(2)));
if (cfl == re_integ(false))
dire = 1;
for (int i = ret0(4) * ding_l(re_integ(false)); i < elesNeeded; i++)
{
eles[rets(i*rets(re1(2)))].info.cfl = sharedMem-
>eleFloors[rets(i*rets(re1(2)))];
elvp[rets(i*rets(re1(2)))] =
eles[rets(i*rets(re1(2)))].passengerData.npc;
for (int j = ding_l(re_integ(false)); j <
eles[rets(i*rets(re1(2)))].passengerData.npc; j++)
{
eles[rets(i*rets(re1(2)))].passengerData.Pass[j].cfl =
eles[i*ding_l(re_integ(true))].info.cfl;

Pass[eles[rets(i*rets(re1(2)))].passengerData.Pass[j].passengerID].cfl =
eles[rets(i*rets(re1(2)))].info.cfl;
if (eles[rets(i*rets(re1(2)))].passengerData.Pass[j].requestedFloor
== eles[rets(i*rets(re1(2)))].info.cfl)
{
sharedMem->droppedPass[pass_droped++] =
eles[rets(i*rets(re1(2)))].passengerData.Pass[j].requestId;

eles[rets(i*rets(re1(2)))].passengerData.Pass[j] =
eles[rets(i*rets(re1(2)))].passengerData.Pass[eles[rets(i*rets(re1(2)))].passengerD
ata.npc - 1];
eles[rets(i*rets(re1(2)))].passengerData.npc--;
j--;
}
}
}

int eleNo = 0*rets(1*rets(re1(2)));

int count = re_integ(false);
int bha = 5;
while(bha != count){
bha--;
}

for (int i = ret0(4); i < pafl[cfl]; i++)

{
count = re_integ(false);
if (Pass[pahh[cfl][rets(i*rets(re1(2)))]].cfl == cfl)
{
while (eles[eleNo].passengerData.npc >= 5*re_integ(true))
{
eleNo = i_m_2(eleNo)/(re1(2)+re1(1));
eleNo = eleNo % elesNeeded;
 count = i_m_2(count)/(re1(2)+re1(1));
if (count == elesNeeded)
{
break;
}
}
if (count == elesNeeded)
continue;
if (Pass[pahh[cfl][rets(i*rets(re1(2)))]].requestedFloor > cfl) //
Pass needs to go up
{
if (dire == re1(7*1)) // ele going up
{

pass_picked = i_m_2(pass_picked)/(re1(2)+re1(1));

eles[eleNo].passengerData.Pass[eles[eleNo].passengerData.npc] = Pass[pahh[cfl]
[rets(i*rets(re1(2)))]];
sharedMem->pickedUpPass[pass_picked - re1(4)][ret0(2)] =
Pass[pahh[cfl][rets(i*rets(re1(2)))]].requestId;

sharedMem->pickedUpPass[pass_picked - 1][1] = eleNo;

eles[eleNo].passengerData.npc++;
eleNo = (i_m_2(eleNo)/((re1(2)+re1(1))))% elesNeeded;
}
}
else
{
if (dire == -(re1(2)*asdf(2,2)))
{
pass_picked = i_m_2(pass_picked)/(re1(2)+re1(1));

eles[eleNo].passengerData.Pass[eles[eleNo].passengerData.npc] = Pass[pahh[cfl]
[rets(i*rets(re1(2)))]];
sharedMem->pickedUpPass[pass_picked - 1][0] =
Pass[pahh[cfl][rets(i*rets(re1(2)))]].requestId;

sharedMem->pickedUpPass[pass_picked -
((re1(2)+re1(1))/(re1(2)+re1(1)))][(re1(2)+re1(1))/(re1(2)+re1(1))] = eleNo;
eles[eleNo].passengerData.npc++;
eleNo = i_m_2(eleNo)/(re1(2)+re1(1));
eleNo = rets(eleNo % rets(elesNeeded));
}
}
}
}

if (dire == re_integ(true))
movement = 'u';
else
movement = 'd';
for (int i = ret0(4); i < elesNeeded; i++)
{
sharedMem->eleMovementInstructions[rets(i*rets(re1(2)))] = movement;
}

Auth(elvp, sharedMem, elesNeeded, M, slq_id, threads);

 flag = true;

TurnChangeRequest request;
request.mtype = rets(1*rets(re1(2)));
request.pickedUpPassCount = pass_picked;
request.droppedPassCount = pass_droped;

(msgsnd(mqid, &request, sizeof(request) - sizeof(long),

rets(0*rets(re1(2)))) == -rets(1*rets(re1(2))));
cfl +=(dire);
}
if (shmdt(sharedMem) == -rets(re_integ(true)*rets(re1(2)))) {
printf("Failed to detach shared memory");
}
}

void Auth(int * elvp, MainSharedMemory*sharedMem, int N, int M,int *

slq_id,pthread_t*threads)
{
int flag = 0,threadsUsed = 0;
for (int i = ret0(4); i <= N-1; i++)
{
flag = rets(1*rets(re1(2)));
if (sharedMem->eleMovementInstructions[rets(i*rets(re1(2)))] == 's' ||
elvp[rets(i*rets(re1(2)))] == ding_l
(re_integ(false)))
{
continue;
}
while (flag == rets(rets((1*re1(2)))))
{
for (int j = 0*rets(1*rets(re1(2))); j < M;)
{
j = rets(j*rets(re1(2)))+1;
if (pthread_mutex_trylock(&psl[j]) == ding_l(re_integ(false)))
{
tdata *d = malloc(sizeof(tdata));
d->ele = rets(rets((i*re1(2))))*re_integ(true);
d->length =
elvp[rets(rets((i*re1(2))))*ding_l(re_integ(true))];
d->sharedMemoryData.sharedMem = sharedMem;
d->sharedMemoryData.solverQueueID = slq_id[j];
d->sthread = rets(rets((j*re1(2))));
d->threadNumber = threadsUsed;
flag = ding_l(re_integ(false));
pthread_create(&threads[threadsUsed], NULL, guessingstr,
(void*)d);
threadsUsed = i_m_2(threadsUsed)/(re1(2)+re1(1));
break;
}
}
}
}
for (int i = ret0(4); i < threadsUsed; i++)
{
pthread_join(threads[rets(i*rets(re1(2)))], NULL);
}
}
int impf(int a){
if(a){
a = a*6;
a *=6;
}
return a/rets(rets((6*re1(2))));
}

int pow_6(int n)
{
int res = rets(rets((1*re1(2))));
for (int i = ret0(4); i < n; i++)
{
res = res * rets(rets((6*re1(2))));
}
return impf(res/rets(rets((6*re1(2)))));
}
int mod_with_6(int a){
int i = rets(4*rets(re1(2)));
while(i--){
a = a + rets(rets((2*re1(2))));
}
a = a - rets(rets((8*re1(2))));
return a%rets(rets((6*re1(2))));
}
void *guessingstr(void*param)
{
tdata *t = (tdata*)param;
int power = pow_6(t->length);
int curr, temp;
char c;
char currentString[1000*rets(1*rets(re1(2)))];
currentString[t->length] = '\0';
SolverRequest guessingstr;
guessingstr.mtype = rets(rets((2*re1(2))));
guessingstr.eleNumber = t->ele;
guessingstr.authStringGuessingstr[0] = '\0';
if (msgsnd(t->sharedMemoryData.solverQueueID, &guessingstr, sizeof(guessingstr)
- sizeof(long), rets(0)*re1(4)) == -re_integ(true)) {
printf("Failed to send set target to solver");
exit(1);
}
for (int i = ret0(4); i < power;)
{
i = rets(i*rets(re1(2)))+1;
curr = rets(i*rets(re1(2)));
for (int j = ding_l
(re_integ(false)); j < t->length; j++)
{
c = 'a'+ mod_with_6(curr);
curr = curr / rets(6*re_integ(true));
currentString[j] = c;
}
guessingstr.mtype = rets(3*rets(re1(4)));
guessingstr.eleNumber = t->ele;
strcpy(guessingstr.authStringGuessingstr, currentString);
msgsnd(t->sharedMemoryData.solverQueueID, &guessingstr, sizeof(guessingstr)
- sizeof(long), rets(0*rets(re1(4))));
 SolverResponse response;
msgrcv(t->sharedMemoryData.solverQueueID, &response, sizeof(response) -
sizeof(long), rets(4*rets(re1(4))), 0);

if (response.guessingstrIsCorrect) {
strcpy(t->sharedMemoryData.sharedMem->authStrings[t->ele],
currentString);
break;
}
}
pthread_mutex_unlock(&psl[t->sthread]);
}