How do I solve this? I get an error. Please help

#include <iostream>
using namespace std;

// Binary Tree Node class
class Node
{  
    public:
    int data;
    Node *left;
    Node *right;
    Node(int x){
        data = x;
        left = NULL;
        right = NULL;
       
    }
};

 
// Insert a value in our BST
Node* insert(Node* root, int value)
{
    if (root == NULL) {
        return new Node(value);
    }

 
// if root node is greater than value, insert value in left subtree
if (value < root->data) {
    root->left = insert(root->left, value);
}

   
// if root is lesser than value, insert value in right subtree
   else {
       root->right = insert(root->right, value);
   }
   
   return root;
}
 

// Function to find maximum node in a BST
Node* maximumNode(Node* root)

{
    while (root->right) {
        root = root->right;
    }

   return root;
}

 
// Pred node is passed by reference meaning it is making changes in the original node
void findPredecessor(Node* root, Node*&pred, int key)
{
    // base case
   if (root == NULL)
   {
       pred = NULL;
       return;
   }
   // if the root is our key node then the predecessor will be the largest node in its left subtree
   if (root->data == key)
   {
       if (root->left != NULL) {
           pred = maximumNode(root->left);
       }
   }

  // if our key value is less than the root node value then we'll search in left subtree for key node
  else if (key < root->data) {
    findPredecessor(root->left, pred, key);
     
  }
   
   // if our key value is more than the root node value then we'll search in right subtree for key node
   else if (key > root->data) {
       // update predecessor to the current node before recursing in the right subtree
       pred = root;
       findPredecessor(root->right, pred, key);
   }
   return;
}

 
int main()
{
    Node* root = NULL;
    int n=0;

   // Taking BST as input
   while(n!=-1) {
       cin>>n;
       root = insert(root, n);
   }

   // Here we'll take input x and then find it's predecessor
   int x;
   cin>>x;
   Node* pred = NULL;
   
   findPredecessor(root, pred, x);

   // -1 will always be the first node in Inorder traversal because we are taking input BST till -1
   // that means the node with predecessor -1 is the first node in Inorder traversal
   if(pred->data != -1) cout << "The predecessor of node " << x << " is " << pred->data;
   else cout << "The predecessor of node doesn't exist";
   
   return 0;
}
return 0;
}