LazyLock::new(|| GlobalBfSharedMutex::new(GlobalTermPool::new()));

    fn new() -> GlobalTermPool {

        let symbol_pool = SymbolPool::new();

        let int_symbol = unsafe { SymbolRef::from_index(&symbol_pool.create("<aterm_int>", 0)) };

        let list_symbol = unsafe { SymbolRef::from_index(&symbol_pool.create("<list_constructor>", 2)) };

        let empty_list_symbol = unsafe { SymbolRef::from_index(&symbol_pool.create("<empty_list>", 0)) };

        GlobalTermPool {

            terms: ATermStorage::new(),

            symbol_pool,

            thread_pools: Vec::new(),

            marked_terms: HashSet::new(),

            marked_symbols: HashSet::new(),

            stack: Vec::new(),

            deletion_hooks: Vec::new(),

            garbage_collection: true,

            int_symbol,

            list_symbol,

            empty_list_symbol,

        }

    }

    pub fn len(&self) -> usize {

        self.terms.len()

    }

    pub fn create_int(&self, value: usize) -> (StablePointer<SharedTerm>, bool) {

        let shared_term = SharedTermLookup {

            symbol: unsafe { SymbolRef::from_index(self.int_symbol.shared()) },

            arguments: &[],

            annotation: Some(value),

        };

        let (index, inserted) = unsafe {

            self.terms

                .insert_equiv_dst(&shared_term, SharedTerm::length_for(&shared_term), |ptr, key| {

                    SharedTerm::construct(ptr, key)

                })

        (index, inserted)

    }

    pub fn create_term_array<'a, 'b, 'c>(

        &'c self,

        symbol: &'b impl Symb<'a, 'b>,

        args: &'c [ATermRef<'c>],

    ) -> (StablePointer<SharedTerm>, bool) {

        let shared_term = SharedTermLookup {

            symbol: SymbolRef::from_symbol(symbol),

            arguments: args,

            annotation: None,

        };

        debug_assert_eq!(

            symbol.shared().arity(),

            shared_term.arguments.len(),

        let (index, inserted) = unsafe {

            self.terms

                .insert_equiv_dst(&shared_term, SharedTerm::length_for(&shared_term), |ptr, key| {

                    SharedTerm::construct(ptr, key)

                })

        (index, inserted)

    }

    pub fn create_symbol<P>(&self, name: impl Into<String> + AsRef<str>, arity: usize, protect: P) -> Symbol

    where

        P: FnOnce(SymbolIndex) -> Symbol,

        protect(self.symbol_pool.create(name, arity))

    }

    pub(crate) fn register_thread_term_pool(&mut self) -> Arc<UnsafeCell<SharedTermProtection>> {

        let protection = Arc::new(UnsafeCell::new(SharedTermProtection {

            protection_set: ProtectionSet::new(),

            symbol_protection_set: ProtectionSet::new(),

            container_protection_set: ProtectionSet::new(),

            index: self.thread_pools.len(),

        }));

        debug!("Registered thread_local protection set(s) {}", self.thread_pools.len());

        self.thread_pools.push(Some(protection.clone()));

        protection

    }

    pub(crate) fn deregister_thread_pool(&mut self, index: usize) {

        debug!("Removed thread_local protection set(s) {index}");

        if let Some(entry) = self.thread_pools.get_mut(index) {

            *entry = None;

        }

    }

    pub(crate) fn trigger_garbage_collection(&mut self) -> usize {

        self.collect_garbage();

        if AGGRESSIVE_GC {

        }

        self.len()

    }

    pub fn register_prefix(&self, prefix: &str) -> Arc<AtomicUsize> {

        self.symbol_pool.create_prefix(prefix)

    }

    fn collect_garbage(&mut self) {

        if !self.garbage_collection {

        }

        self.marked_terms.clear();

        self.marked_symbols.clear();

        self.stack.clear();

        self.marked_symbols.insert(self.int_symbol.shared().copy());

        self.marked_symbols.insert(self.list_symbol.shared().copy());

        self.marked_symbols.insert(self.empty_list_symbol.shared().copy());

        let mut marker = Marker {

            marked_terms: &mut self.marked_terms,

            marked_symbols: &mut self.marked_symbols,

            stack: &mut self.stack,

        };

        let mark_time = Instant::now();

        for pool in self.thread_pools.iter().flatten() {

            let pool = unsafe { &mut *pool.get() };

            for (_root, symbol) in pool.symbol_protection_set.iter() {

                debug_trace!("Marking root {_root} symbol {symbol:?}");

                // Remove all symbols that are not protected

                marker.marked_symbols.insert(symbol.copy());

            }

            for (_root, term) in pool.protection_set.iter() {

                debug_trace!("Marking root {_root} term {term:?}");

                unsafe {

                    ATermRef::from_index(term).mark(&mut marker);

                }

            for (_, container) in pool.container_protection_set.iter() {

                container.mark(&mut marker);

            }

        let mark_time_elapsed = mark_time.elapsed();

        let collect_time = Instant::now();

        let num_of_terms = self.len();

        let num_of_symbols = self.symbol_pool.len();

        self.terms.retain(|term| {

            if !self.marked_terms.contains(term) {

                debug_trace!("Dropping term: {:?}", term);

                for (symbol, hook) in &self.deletion_hooks {

                return false;

            }

            true

        });

        self.symbol_pool.retain(|symbol| {

            if !self.marked_symbols.contains(symbol) {

                debug_trace!("Dropping symbol: {:?}", symbol);

                return false;

            }

            true

        });

        debug!(

        debug!("{}", self.metrics());

        for pool in self.thread_pools.iter().flatten() {

            let pool = unsafe { &mut *pool.get() };

            debug!("{}", pool.metrics());

    }

    pub(crate) fn get_int_symbol(&self) -> &SymbolRef<'static> {

        &self.int_symbol

    }

    pub(crate) fn get_list_symbol(&self) -> &SymbolRef<'static> {

        &self.list_symbol

    }

    pub(crate) fn get_empty_list_symbol(&self) -> &SymbolRef<'static> {

        &self.empty_list_symbol

    }

    pub fn mark(&mut self, term: &ATermRef<'_>) {

        if !self.marked_terms.contains(term.shared()) {

            self.stack.push(term.shared().copy());

            while let Some(term) = self.stack.pop() {

                self.marked_terms.insert(term.copy());

                self.marked_symbols.insert(term.symbol().shared().copy());

                for arg in term.arguments()[0..term.symbol().arity()].iter() {

                    if !self.marked_terms.contains(arg.shared()) {

                        self.marked_terms.insert(arg.shared().copy());

                        self.marked_symbols.insert(arg.get_head_symbol().shared().copy());

                        self.stack.push(arg.shared().copy());

                    }

        }

    }

    pub fn mark_symbol(&mut self, symbol: &SymbolRef<'_>) {

        self.marked_symbols.insert(symbol.shared().copy());

    }

    fn test_maximal_sharing() {

        random_test(100, |rng| {

            let mut terms = HashMap::new();

            for _ in 0..1000 {

                let term = random_term(rng, &[("f".into(), 2), ("g".into(), 1)], &["a".to_string()], 10);

                let representation = format!("{}", term);

                if let Some(entry) = terms.get(&representation) {

                    assert_eq!(term, *entry, "There is another term with the same representation");

                } else {

                    terms.insert(representation, term);

                }

        });

    }