Java | JavaScript | TypeScript | C++ | C# | Kotlin | Go Solution.
```Java []
import java.util.List;
import java.util.PriorityQueue;

public class TaskManager {

    private record Task(int userID, int taskID, int priority) {}

    private static final int[] USER_ID_RANGE = {1, (int) Math.pow(10, 5)};
    private static final int[] TASK_ID_RANGE = {1, (int) Math.pow(10, 5)};
    private static final int[] PRIORITY_RANGE = {1, (int) Math.pow(10, 9)};

    private static final int NOT_FOUND = -1;
    private static final int REMOVED = -2;
    private static final Task REMOVED_TASK = new Task(REMOVED, REMOVED, REMOVED);

    private final Task[] tasks = new Task[TASK_ID_RANGE[1] + 1];
    private final PriorityQueue<Task> maxHeap = new PriorityQueue<>((first, second) -> comparator(first, second));

    public TaskManager(List<List<Integer>> initialTasks) {
        for (List<Integer> current : initialTasks) {
            int userID = current.get(0);
            int taskID = current.get(1);
            int priority = current.get(2);

            tasks[taskID] = new Task(userID, taskID, priority);
            maxHeap.add(new Task(userID, taskID, priority));
        }
    }

    private int comparator(Task first, Task second) {
        return (first.priority == second.priority) ? (second.taskID - first.taskID) : (second.priority - first.priority);
    }

    public void add(int userID, int taskID, int priority) {
        tasks[taskID] = new Task(userID, taskID, priority);
        maxHeap.add(new Task(userID, taskID, priority));
    }

    public void edit(int taskID, int newPriority) {
        int userID = tasks[taskID].userID;
        tasks[taskID] = new Task(userID, taskID, newPriority);
        maxHeap.add(new Task(userID, taskID, newPriority));
    }

    public void rmv(int taskID) {
        tasks[taskID] = REMOVED_TASK;
    }

    public int execTop() {
        int userID = NOT_FOUND;

        while (!maxHeap.isEmpty() && userID == NOT_FOUND) {
            Task current = maxHeap.poll();
            if (taskFound(current)) {
                userID = current.userID;
                tasks[current.taskID] = REMOVED_TASK;
            }
        }
        return userID;
    }

    private boolean taskFound(Task current) {
        int taskID = current.taskID;
        return current.userID == tasks[taskID].userID
                && current.taskID == tasks[taskID].taskID
                && current.priority == tasks[taskID].priority;
    }
}
```
```JavaScript []
// const {PriorityQueue} = require('@datastructures-js/priority-queue');
/*
 PriorityQueue is internally included in the solution file on leetcode.
 It is just for information. When running the application on leetcode, 
 it should stay commented out. 
 */

class TaskManager {

    #USER_ID_RANGE = [1, Math.pow(10, 5)];
    #TASK_ID_RANGE = [1, Math.pow(10, 5)];
    #PRIORITY_RANGE = [1, Math.pow(10, 9)];

    #NOT_FOUND = -1;
    #REMOVED = -2;
    #REMOVED_TASK = new Task(this.#REMOVED, this.#REMOVED, this.#REMOVED);

    #tasks = new Array(this.#TASK_ID_RANGE[1] + 1);
    #maxHeap = new PriorityQueue((first, second) => this.#comparator(first, second));

    /**
     * @param {number[][]} initialTasks
     */
    constructor(initialTasks) {
        for (let [userID, taskID, priority] of initialTasks) {
            this.#tasks[taskID] = new Task(userID, taskID, priority);
            this.#maxHeap.enqueue(new Task(userID, taskID, priority));
        }
    }

    /** 
     * @param {Task} first
     * @param {Task} second 
     * @return {number}
     */
    #comparator(first, second) {
        return (first.priority === second.priority) ? (second.taskID - first.taskID) : (second.priority - first.priority);
    }

    /** 
     * @param {number} userID 
     * @param {number} taskID 
     * @param {number} priority
     * @return {void}
     */
    add(userID, taskID, priority) {
        this.#tasks[taskID] = new Task(userID, taskID, priority);
        this.#maxHeap.enqueue(new Task(userID, taskID, priority));
    }

    /** 
     * @param {number} taskID 
     * @param {number} newPriority
     * @return {void}
     */
    edit(taskID, newPriority) {
        const userID = this.#tasks[taskID].userID;
        this.#tasks[taskID] = new Task(userID, taskID, newPriority);
        this.#maxHeap.enqueue(new Task(userID, taskID, newPriority));
    }

    /** 
     * @param {number} taskID
     * @return {void}
     */
    rmv(taskID) {
        this.#tasks[taskID] = this.#REMOVED_TASK;
    }

    /**
     * @return {number}
     */
    execTop() {
        let userID = this.#NOT_FOUND;

        while (!this.#maxHeap.isEmpty() && userID === this.#NOT_FOUND) {
            const current = this.#maxHeap.dequeue();
            if (this.#taskFound(current)) {
                userID = current.userID;
                this.#tasks[current.taskID] = this.#REMOVED_TASK;
            }
        }
        return userID;
    }

    /** 
     * @param {Task} current
     * @return {number}
     */
    #taskFound(current) {
        const taskID = current.taskID;
        return current.userID === this.#tasks[taskID].userID
                && current.taskID === this.#tasks[taskID].taskID
                && current.priority === this.#tasks[taskID].priority;
    }

}

class Task {

    /** 
     * @param {number} userID
     * @param {number} taskID 
     * @param {number} priority
     */
    constructor(userID, taskID, priority) {
        this.userID = userID;
        this.taskID = taskID;
        this.priority = priority;
    }
}
```
```TypeScript []
// const {PriorityQueue} = require('@datastructures-js/priority-queue');
/*
 PriorityQueue is internally included in the solution file on leetcode.
 It is just for information. When running the application on leetcode, 
 it should stay commented out. 
 */


class TaskManager {

    private USER_ID_RANGE = [1, Math.pow(10, 5)];
    private TASK_ID_RANGE = [1, Math.pow(10, 5)];
    private PRIORITY_RANGE = [1, Math.pow(10, 9)];

    private NOT_FOUND = -1;
    private REMOVED = -2;
    private REMOVED_TASK = new Task(this.REMOVED, this.REMOVED, this.REMOVED);

    private tasks = new Array(this.TASK_ID_RANGE[1] + 1);
    private maxHeap = new PriorityQueue((first, second) => this.comparator(first, second));

    constructor(initialTasks: number[][]) {
        for (let [userID, taskID, priority] of initialTasks) {
            this.tasks[taskID] = new Task(userID, taskID, priority);
            this.maxHeap.enqueue(new Task(userID, taskID, priority));
        }
    }

    private comparator(first: Task, second: Task): number {
        return (first.priority === second.priority) ? (second.taskID - first.taskID) : (second.priority - first.priority);
    }

    add(userID: number, taskID: number, priority: number): void {
        this.tasks[taskID] = new Task(userID, taskID, priority);
        this.maxHeap.enqueue(new Task(userID, taskID, priority));
    }

    edit(taskID: number, newPriority: number): void {
        const userID = this.tasks[taskID].userID;
        this.tasks[taskID] = new Task(userID, taskID, newPriority);
        this.maxHeap.enqueue(new Task(userID, taskID, newPriority));
    }

    rmv(taskID: number): void {
        this.tasks[taskID] = this.REMOVED_TASK;
    }

    execTop(): number {
        let userID = this.NOT_FOUND;

        while (!this.maxHeap.isEmpty() && userID === this.NOT_FOUND) {
            const current = this.maxHeap.dequeue();
            if (this.taskFound(current)) {
                userID = current.userID;
                this.tasks[current.taskID] = this.REMOVED_TASK;
            }
        }
        return userID;
    }

    private taskFound(current) {
        const taskID = current.taskID;
        return current.userID === this.tasks[taskID].userID
            && current.taskID === this.tasks[taskID].taskID
            && current.priority === this.tasks[taskID].priority;
    }
}

class Task {

    userID: number;
    taskID: number;
    priority: number;

    constructor(userID: number, taskID: number, priority: number) {
        this.userID = userID;
        this.taskID = taskID;
        this.priority = priority;
    }
}
```
```C++ []
#include <queue>
#include <array>
#include <vector>
using namespace std;

class TaskManager {

    struct Task {
        int userID{};
        int taskID{};
        int priority{};

        Task() = default;
        Task(int userID, int taskID, int priority) :userID{ userID }, taskID{ taskID }, priority{ priority } {};
    };

    struct Comparator {
        auto operator()(const Task& first, const Task& second) const {
            if (first.priority == second.priority) {
                return second.taskID > first.taskID;
            }
            return second.priority > first.priority;
        }
    };

    /*
    The definitions for 'one_hundred_thousand' and 'one_billion' are for the sake of legibility
    and clarity of intended value. These are used instead of pow(10, 5) and pow(10, 9)
    because 'pow(...)' is not a compile time constant.

    We need 'TASK_ID_RANGE' to be a constexpr in order to initialize array 'tasks' in the following way:
    array<Task, TASK_ID_RANGE[1] + 1> tasks

    As for the arrays 'USER_ID_RANGE' and 'PRIORITY_RANGE': these arrays are included for the sake of completeness
    and their values are not actually used in the solution.
    */
    static const int one_hundred_thousand = 100000;
    static const int one_billion = 1000000000;

    inline static constexpr array<int, 2> USER_ID_RANGE = { 1, one_hundred_thousand };
    inline static constexpr array<int, 2> TASK_ID_RANGE = { 1, one_hundred_thousand };
    inline static constexpr array<int, 2> PRIORITY_RANGE = { 1, one_billion };

    static const int NOT_FOUND = -1;
    static const int REMOVED = -2;
    inline static const Task REMOVED_TASK{ REMOVED, REMOVED, REMOVED };

    array<Task, TASK_ID_RANGE[1] + 1> tasks;
    priority_queue<Task, vector<Task>, Comparator> maxHeap;

public:
    TaskManager(vector<vector<int>>& initialTasks) {

        for (const auto& current : initialTasks) {
            int userID = current[0];
            int taskID = current[1];
            int priority = current[2];

            tasks[taskID].userID = userID;
            tasks[taskID].taskID = taskID;
            tasks[taskID].priority = priority;

            maxHeap.emplace(userID, taskID, priority);
        }
    }

    void add(int userID, int taskID, int priority) {
        tasks[taskID].userID = userID;
        tasks[taskID].taskID = taskID;
        tasks[taskID].priority = priority;;
        maxHeap.emplace(userID, taskID, priority);
    }

    void edit(int taskID, int newPriority) {
        int userID = tasks[taskID].userID;
        tasks[taskID].priority = newPriority;
        maxHeap.emplace(userID, taskID, newPriority);
    }

    void rmv(int taskID) {
        tasks[taskID] = REMOVED_TASK;
    }

    int execTop() {
        int userID = NOT_FOUND;

        while (!maxHeap.empty() && userID == NOT_FOUND) {
            Task current = maxHeap.top();
            maxHeap.pop();

            if (taskFound(current)) {
                userID = current.userID;
                tasks[current.taskID] = REMOVED_TASK;
            }
        }
        return userID;
    }

private:
    bool taskFound(const Task& current) const {
        int taskID = current.taskID;
        return current.userID == tasks[taskID].userID
                && current.taskID == tasks[taskID].taskID
                && current.priority == tasks[taskID].priority;
    }
};
```
```C# []
using System;
using System.Collections.Generic;

public class TaskManager
{
    private record Task(int userID, int taskID, int priority) { }

    private static readonly int[] USER_ID_RANGE = { 1, (int)Math.Pow(10, 5) };
    private static readonly int[] TASK_ID_RANGE = { 1, (int)Math.Pow(10, 5) };
    private static readonly int[] PRIORITY_RANGE = { 1, (int)Math.Pow(10, 9) };

    private static readonly int NOT_FOUND = -1;
    private static readonly int REMOVED = -2;
    private static readonly Task REMOVED_TASK = new Task(REMOVED, REMOVED, REMOVED);

    private readonly Task[] tasks = new Task[TASK_ID_RANGE[1] + 1];
    private static Comparer<Task> comparator = Comparer<Task>.Create((first, second) => (first.priority == second.priority) ? (second.taskID - first.taskID) : (second.priority - first.priority));
    private readonly PriorityQueue<Task, Task> maxHeap = new PriorityQueue<Task, Task>(comparator);


    public TaskManager(IList<IList<int>> initialTasks)
    {
        foreach (var current in initialTasks)
        {
            int userID = current[0];
            int taskID = current[1];
            int priority = current[2];

            tasks[taskID] = new Task(userID, taskID, priority);
            maxHeap.Enqueue(new Task(userID, taskID, priority), new Task(userID, taskID, priority));
        }
    }

    public void Add(int userID, int taskID, int priority)
    {
        tasks[taskID] = new Task(userID, taskID, priority);
        maxHeap.Enqueue(new Task(userID, taskID, priority), new Task(userID, taskID, priority));
    }

    public void Edit(int taskID, int newPriority)
    {
        int userID = tasks[taskID].userID;
        tasks[taskID] = new Task(userID, taskID, newPriority);
        maxHeap.Enqueue(new Task(userID, taskID, newPriority), new Task(userID, taskID, newPriority));
    }

    public void Rmv(int taskID)
    {
        tasks[taskID] = REMOVED_TASK;
    }

    public int ExecTop()
    {
        int userID = NOT_FOUND;

        while (maxHeap.Count > 0 && userID == NOT_FOUND)
        {
            Task current = maxHeap.Dequeue();
            if (TaskFound(current))
            {
                userID = current.userID;
                tasks[current.taskID] = REMOVED_TASK;
            }
        }
        return userID;
    }

    private bool TaskFound(Task current)
    {
        int taskID = current.taskID;
        return current.userID == tasks[taskID].userID
                && current.taskID == tasks[taskID].taskID
                && current.priority == tasks[taskID].priority;
    }
}
```
```Kotlin []
import kotlin.math.pow

class TaskManager(initialTasks: List<List<Int>>) {

    private data class Task(val userID: Int, val taskID: Int, val priority: Int) {}

    private companion object {
        val USER_ID_RANGE = intArrayOf(1, (10.0).pow(5).toInt())
        val TASK_ID_RANGE = intArrayOf(1, (10.0).pow(5).toInt())
        val PRIORITY_RANGE = intArrayOf(1, (10.0).pow(9).toInt())

        const val NOT_FOUND = -1
        const val REMOVED = -2
        val REMOVED_TASK = Task(REMOVED, REMOVED, REMOVED)
    }

    private val tasks = arrayOfNulls<Task>(TASK_ID_RANGE[1] + 1)
    private val maxHeap = java.util.PriorityQueue<Task> { first, second -> comparator(first, second) }

    init {
        for (current in initialTasks) {
            val userID = current[0]
            val taskID = current[1]
            val priority = current[2]

            tasks[taskID] = Task(userID, taskID, priority)
            maxHeap.add(Task(userID, taskID, priority))
        }
    }


    private fun comparator(first: Task, second: Task): Int {
        if (first.priority == second.priority) {
            return second.taskID - first.taskID
        }
        return second.priority - first.priority
    }

    fun add(userID: Int, taskID: Int, priority: Int) {
        tasks[taskID] = Task(userID, taskID, priority)
        maxHeap.add(Task(userID, taskID, priority))
    }

    fun edit(taskID: Int, newPriority: Int) {
        val userID = tasks[taskID]!!.userID
        tasks[taskID] = Task(userID, taskID, newPriority)
        maxHeap.add(Task(userID, taskID, newPriority))
    }

    fun rmv(taskID: Int) {
        tasks[taskID] = REMOVED_TASK
    }

    fun execTop(): Int {
        var userID = NOT_FOUND

        while (!maxHeap.isEmpty() && userID == NOT_FOUND) {
            val current = maxHeap.poll()
            if (taskFound(current)) {
                userID = current.userID
                tasks[current.taskID] = REMOVED_TASK
            }
        }
        return userID
    }

    private fun taskFound(current: Task): Boolean {
        val taskID = current.taskID
        return current.userID == tasks[taskID]!!.userID
                && current.taskID == tasks[taskID]!!.taskID
                && current.priority == tasks[taskID]!!.priority
    }
}
```
```Go []
package main

import (
    "container/heap"
    "math"
)

var USER_ID_RANGE = [2]int{1, int(math.Pow(10.0, 5.0))}
var TASK_ID_RANGE = [2]int{1, int(math.Pow(10.0, 5.0))}
var PRIORITY_RANGE = [2]int{1, int(math.Pow(10.0, 9.0))}

const NOT_FOUND = -1
const REMOVED = -2

var REMOVED_TASK = NewTask(REMOVED, REMOVED, REMOVED)

type TaskManager struct {
    tasks   []*Task
    maxHeap PriorityQueue
}

func Constructor(initialTasks [][]int) TaskManager {
    taskManager := TaskManager{
        tasks:   make([]*Task, TASK_ID_RANGE[1] + 1),
        maxHeap: make(PriorityQueue, 0),
    }

    for _, current := range initialTasks {
        userID := current[0]
        taskID := current[1]
        priority := current[2]

        taskManager.tasks[taskID] = NewTask(userID, taskID, priority)
        heap.Push(&taskManager.maxHeap, NewTask(userID, taskID, priority))
    }
    return taskManager
}

func (this *TaskManager) Add(userID int, taskID int, priority int) {
    this.tasks[taskID] = NewTask(userID, taskID, priority)
    heap.Push(&this.maxHeap, NewTask(userID, taskID, priority))
}

func (this *TaskManager) Edit(taskID int, newPriority int) {
    userID := this.tasks[taskID].userID
    this.tasks[taskID] = NewTask(userID, taskID, newPriority)
    heap.Push(&this.maxHeap, NewTask(userID, taskID, newPriority))
}

func (this *TaskManager) Rmv(taskID int) {
    this.tasks[taskID] = REMOVED_TASK
}

func (this *TaskManager) ExecTop() int {
    userID := NOT_FOUND

    for this.maxHeap.Len() > 0 && userID == NOT_FOUND {
        current := heap.Pop(&this.maxHeap).(*Task)
        if this.taskFound(current) {
            userID = current.userID
            this.tasks[current.taskID] = REMOVED_TASK
        }
    }
    return userID
}

func (this *TaskManager) taskFound(current *Task) bool {
    taskID := current.taskID
    return current.userID == this.tasks[taskID].userID &&
            current.taskID == this.tasks[taskID].taskID &&
            current.priority == this.tasks[taskID].priority
}

type Task struct {
    userID   int
    taskID   int
    priority int
}

func NewTask(userID int, taskID int, priority int) *Task {
    task := &Task{
        userID:   userID,
        taskID:   taskID,
        priority: priority,
    }
    return task
}

type PriorityQueue []*Task

func (pq PriorityQueue) Len() int {
    return len(pq)
}

func (pq PriorityQueue) Less(first int, second int) bool {
    if pq[first].priority == pq[second].priority {
        return pq[first].taskID > pq[second].taskID
    }
    return pq[first].priority > pq[second].priority
}

func (pq PriorityQueue) Swap(first int, second int) {
    pq[first], pq[second] = pq[second], pq[first]
}

func (pq *PriorityQueue) Push(object any) {
    task := object.(*Task)
    *pq = append(*pq, task)
}

func (pq *PriorityQueue) Pop() any {
    task := (*pq)[pq.Len() - 1]
    (*pq)[pq.Len() - 1] = nil
    *pq = (*pq)[0 : pq.Len() - 1]
    return task
}
```

['C++', 'Java', 'Go', 'TypeScript', 'Kotlin', 'JavaScript', 'C#']