#include

#include

#include

#include

#include

#include

#include

#include

#define MAX$\_$STRING$\_$SIZE $256$

#define HASH$\_$TABLE$\_$SIZE $100003$

struct Message $\{$

long mtype;

int key;

$\}$;

typedef struct WordCountNode $\{$

char $*$word;

int count;

struct WordCountNode $*$next;

$\}$ WordCountNode;

unsigned int hash$\_$function$($const char $*$str$)\{$

unsigned int hash $=5381$;

for $($const char $*$s $=$ str; $*$s $!=\text{'}\backslash 0\text{'}$; s$++)\{$

hash $=(($hash $<<5)+$ hash$)+(*$s$)$;

$\}$

return hash $\%$ HASH$\_$TABLE$\_$SIZE;

$\}$

void insert$\_$word$($WordCountNode $**$hash$\_$table, const char $*$word$)\{$

unsigned int index $=$ hash$\_$function$($word$)$;

WordCountNode $*$current$\_$node $=$ hash$\_$table$[$index$]$;

while $($current$\_$node $!=$ NULL$)\{$

if $($strcmp$($current$\_$node$->$word, word$)==0)\{$

current$\_$node$->$count$++$;

return;

$\}$

current$\_$node $=$ current$\_$node$->$next;

$\}$

WordCountNode $*$new$\_$node $=$ malloc$($sizeof$($WordCountNode$))$;

if $($new$\_$node $==$ NULL$)\{$

perror$("$Failed to allocate memory for new word"$)$;

exit$($EXIT$\_$FAILURE$)$;

$\}$

new$\_$node$->$word $=$ malloc$(($strlen$($word$)+1)*$ sizeof$($char$))$;

if $($new$\_$node$->$word $==$ NULL$)\{$

free$($new$\_$node$)$;

perror$("$Failed to allocate memory for word string"$)$;

exit$($EXIT$\_$FAILURE$)$;

$\}$

strcpy$($new$\_$node$->$word, word$)$;

new$\_$node$->$count $=1$;

new$\_$node$->$next $=$ hash$\_$table$[$index$]$;

hash$\_$table$[$index$]=$ new$\_$node;

$\}$

int get$\_$word$\_$count$($WordCountNode $**$hash$\_$table, const char $*$word$)\{$

unsigned int index $=$ hash$\_$function$($word$)$;

WordCountNode $*$current$\_$node $=$ hash$\_$table$[$index$]$;

while $($current$\_$node $!=$ NULL$)\{$

if $($strcmp$($current$\_$node$->$word, word$)==0)\{$

return current$\_$node$->$count;

$\}$

current$\_$node $=$ current$\_$node$->$next;

$\}$

return $0$;

$\}$

void free$\_$hash$\_$table$($WordCountNode $**$hash$\_$table$)\{$

for $($int i $=0$; i $<$ HASH$\_$TABLE$\_$SIZE; i$++)\{$

WordCountNode $*$current$\_$node $=$ hash$\_$table$[$i$]$;

while $($current$\_$node $!=$ NULL$)\{$

WordCountNode $*$temp $=$ current$\_$node;

current$\_$node $=$ current$\_$node$->$next;

free$($temp$->$word$)$;

free$($temp$)$;

$\}$

$\}$

free$($hash$\_$table$)$;

$\}$

int main$($int argc, char $*$argv$[])\{$

if $($argc $!=2)\{$

fprintf$($stderr$,$ "Usage: $\%$s

$",$ argv$[0])$;

exit$($EXIT$\_$FAILURE$)$;

$\}$

char $*$test$\_$case$\_$number $=$ argv$[1]$;

char input$\_$filename$[256]$;

char words$\_$filename$[256]$;

snprintf$($input$\_$filename, sizeof$($input$\_$filename$),$ "input$\%$s$.$txt$",$ test$\_$case$\_$number$)$;

snprintf$($words$\_$filename, sizeof$($words$\_$filename$),$ "words$\%$s$.$txt$",$ test$\_$case$\_$number$)$;

FILE $*$input$\_$file $=$ fopen$($input$\_$filename, $"$r$")$;

if $($input$\_$file $==$ NULL$)\{$

perror$("$Error opening input file"$)$;

exit$($EXIT$\_$FAILURE$)$;

$\}$

int matrix$\_$size, string$\_$size;

key$\_$t shm$\_$key, msg$\_$key;

if $($fscanf$($input$\_$file, $"\%$d $\%$d $\%$d $\%$d$",$ &matrix$\_$size, &string$\_$size, &shm$\_$key, &msg$\_$key$)!=4)\{$

fprintf$($stderr$,$ "Error reading input file

$")$;

fclose$($input$\_$file$)$;

exit$($EXIT$\_$FAILURE$)$;

$\}$

fclose$($input$\_$file$)$;

if $($string$\_$size $>$ MAX$\_$STRING$\_$SIZE $||$ string$\_$size $<=0)\{$

fprintf$($stderr$,$ "Invalid string size

$")$;

exit$($EXIT$\_$FAILURE$)$;

$\}$

size$\_$t shm$\_$size $=$ sizeof$($char$[$matrix$\_$size$][$matrix$\_$size$][$string$\_$size$])$;

int shm$\_$id $=$ shmget$($shm$\_$key, shm$\_$size, $0666)$;

if $($shm$\_$id $==-1)\{$

perror$("$shmget failed"$)$;

exit$($EXIT$\_$FAILURE$)$;

$\}$

char $(*$shared$\_$matrix$)[$matrix$\_$size$][$string$\_$size$]=$ shmat$($shm$\_$id$,$ NULL, $0)$;

if $($shared$\_$matrix $==($void $*)-1)\{$

perror$("$shmat failed"$)$;

exit$($EXIT$\_$FAILURE$)$;

$\}$

int msg$\_$id $=$ msgget$($msg$\_$key, $0666)$;

if $($msg$\_$id $==-1)\{$

perror$("$msgget failed"$)$;

shmdt$($shared$\_$matrix$)$;

exit$($EXIT$\_$FAILURE$)$;

$\}$

FILE $*$words$\_$file $=$ fopen$($words$\_$filename, $"$r$")$;

if $($words$\_$file $==$ NULL$)\{$

perror$("$words file open failed"$)$;

shmdt$($shared$\_$matrix$)$;

exit$($EXIT$\_$FAILURE$)$;

$\}$

WordCountNode $**$hash$\_$table $=$ calloc$($HASH$\_$TABLE$\_$SIZE, sizeof$($WordCountNode $*))$;

if $($hash$\_$table $==$ NULL$)\{$

perror$("$hash table allocation failed"$)$;

fclose$($words$\_$file$)$;

shmdt$($shared$\_$matrix$)$;

exit$($EXIT$\_$FAILURE$)$;

$\}$

char word$[$MAX$\_$STRING$\_$SIZE$]$;

while $($fscanf$($words$\_$file, $"\%255$s$",$ word$)!=$ EOF$)\{$

insert$\_$word$($hash$\_$table, word$)$;

$\}$

fclose$($words$\_$file$)$;

int total$\_$diagonals $=2*$ matrix$\_$size $-1$;

int caesar$\_$key $=0$;

size$\_$t msg$\_$size $=$ sizeof$($struct Message$)-$ sizeof$($long$)$;

for $($int diag $=0$; diag $<$ total$\_$diagonals; diag$++)\{$

int diag$\_$sum$\_$counts $=0$;

for $($int i $=0$; i $<$ matrix$\_$size; i$++)\{$

int j $=$ diag $-$ i;

if $($j $>=0$ && j $<$ matrix$\_$size$)\{$

char $*$encoded$\_$word $=$ shared$\_$matrix$[$i$][$j$]$;

char decoded$\_$word$[$MAX$\_$STRING$\_$SIZE$]$;

int k;

int shift $=$ caesar$\_$key $\%26$;

$\}$

$\}$

shmdt$($shared$\_$matrix$)$;

free$\_$hash$\_$table$($hash$\_$table$)$;

return $0$;

$\}$

rewrite and humanize this code withoiut losing any logic.