Adjust the following C$++$ code to meet the requirements and avoid the segmentation error. Requirements: Write a Lock$-$Free Sorted Concurrent Linked List and retain the compare$-$and$-$swap. Use a worker$-$crew thread pool with C$++11$ fork$/$join multithreading. It should utilize $100,000$ total list actions. All $100,000$ iterations of

the parallel for loop should be simultaneously attempting to insert, read, or delete linked list items. For each iteration, a thread should randomly decide two items. $1)$ Node data between $0$ and $99$ inclusive. $2)$ An action of insertion $(10\%$ probability$),$ removal $(10\%$ probability$),$ lookup$/$retrieval $(80\%$ probability$).$ After generating those two, the action is performed. For example, suppose a random number generator creates $37$ and $1.$ The $37$ is the data, and $1$ can mean remove. The thread searches down the link list for a node containing $37,$ and upon finding one, attempts to delete it$.$ If $37$ is not found, then after the list is iterated, the action is considered complete. Additionally, upon inserting the list can contain duplicates of the same value. Upon removal, only remove the first discovered instance. Upon searching, only find the first discovered instance $($we are assuming duplicates are not allowed$).$Code: #include

#include

#include

#include

#include

#include

template

class LockFreeSortedList $\{$

private:

struct Node $\{$

T data;

std::atomic next;

Node$($T val$)$ : data$($val$),$ next$($nullptr$)\{\}$

$\}$;

std::atomic head;

public:

LockFreeSortedList$()$ : head$($nullptr$)\{\}$

~LockFreeSortedList$()\{$

Node$*$ curr;

while $(($curr $=$ head.load$())!=$ nullptr$)\{$

head.store$($curr$->$next.load$())$;

delete curr;

$\}$

$\}$

bool insert$($T value$)\{$

Node$*$ newNode $=$ new Node$($value$)$;

newNode$->$next $=$ nullptr;

Node$*$ curr $=$ head.load$($std::memory$\_$order$\_$relaxed$)$;

Node$*$ prev $=$ nullptr;

while $($true$)\{$

if $(!$curr $||$ curr$->$data $>=$ value$)\{$

if $($prev$)\{$

newNode$->$next $=$ curr;

if $($prev$->$next.compare$\_$exchange$\_$strong$($curr$,$ newNode$))\{$

return true;

$\}$

curr $=$ prev$->$next.load$($std::memory$\_$order$\_$relaxed$)$;

$\}$ else $\{$

newNode$->$next $=$ head.load$($std::memory$\_$order$\_$relaxed$)$;

if $($head$.$compare$\_$exchange$\_$strong$($curr$,$ newNode$))\{$

return true;

$\}$

curr $=$ head.load$($std::memory$\_$order$\_$relaxed$)$;

$\}$

$\}$ else $\{$

prev $=$ curr;

curr $=$ curr$->$next.load$($std::memory$\_$order$\_$relaxed$)$;

$\}$

$\}$

$\}$

bool remove$($T value$)\{$

Node$*$ curr $=$ head.load$($std::memory$\_$order$\_$relaxed$)$;

Node$*$ prev $=$ nullptr;

while $($curr && curr$->$data $<$ value$)\{$

prev $=$ curr;

curr $=$ curr$->$next.load$($std::memory$\_$order$\_$relaxed$)$;

$\}$

if $(!$curr $||$ curr$->$data $!=$ value$)\{$

return false;

$\}$

Node$*$ next $=$ curr$->$next.load$($std::memory$\_$order$\_$relaxed$)$;

if $($prev$)\{$

if $(!$prev$->$next.compare$\_$exchange$\_$strong$($curr$,$ next$))\{$

return false;

$\}$

$\}$ else $\{$

if $(!$head.compare$\_$exchange$\_$strong$($curr$,$ next$))\{$

return false;

$\}$

$\}$

delete curr;

return true;

$\}$

bool contains$($T value$)\{$

Node$*$ curr $=$ head.load$($std::memory$\_$order$\_$relaxed$)$;

while $($curr && curr$->$data $<$ value$)\{$

curr $=$ curr$->$next.load$($std::memory$\_$order$\_$relaxed$)$;

$\}$

return curr && curr$->$data $==$ value;

$\}$

$\}$;

void performRandomOperation$($LockFreeSortedList& list, int num$\_$operations$)\{$

std::random$\_$device rd;

std::mt$19937$ gen$($rd$())$;

std::uniform$\_$int$\_$distribution$<>$ dis$(0,99)$;

std::uniform$\_$int$\_$distribution$<>$ actionDis$(1,100)$;

for $($int i $=0$; i $<$ num$\_$operations; $++$i$)\{$

int data $=$ dis$($gen$)$;

int action $=$ actionDis$($gen$)$;

if $($action $<=10)\{$

list.insert$($data$)$;

$\}$ else if $($action $>10$ && action $<=20)\{$

list.remove$($data$)$;

$\}$ else $\{$

list.contains$($data$)$;

$\}$

$\}$

$\}$

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

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

std::cerr $<<$ "Usage: $"<<$ argv$[0]<<""<<$ std::endl;

return $1$;

$\}$

int num$\_$threads $=$ std::stoi$($argv$[1])$;

int num$\_$operations$\_$per$\_$thread $=100000/$ num$\_$threads;

LockFreeSortedList list;

std::vector threads;

auto start $=$ std::chrono::high$\_$resolution$\_$clock::now$()$;

for $($int i $=0$; i $<$ num$\_$threads; $++$i$)\{$

threads.emplace$\_$back$($performRandomOperation$,$ std::ref$($list$),$ num$\_$operations$\_$per$\_$thread$)$;

$\}$ for $($auto& thread : thread : threads$)\{$

thread.join$()$;

$\}$ auto end $=$ std::chrono::high$\_$resolution$\_$clock::now$()$;