wasm-idle 0.7.0 → 0.7.2

package/dist/clang/gccCompat.js

@@ -0,0 +1,767 @@
+const treePolicyHeader = String.raw `#ifndef WASM_CLANG_EXT_PB_DS_TREE_POLICY_HPP
+#define WASM_CLANG_EXT_PB_DS_TREE_POLICY_HPP
+
+#include <cstddef>
+
+namespace __gnu_pbds {
+
+struct null_type {};
+struct rb_tree_tag {};
+struct splay_tree_tag {};
+struct ov_tree_tag {};
+
+template <typename Node_CItr, typename Node_Itr, typename Cmp_Fn, typename Allocator>
+class null_node_update {
+public:
+	typedef Node_CItr node_const_iterator;
+	typedef Node_Itr node_iterator;
+	typedef Cmp_Fn cmp_fn;
+	typedef Allocator allocator_type;
+};
+
+template <typename Node_CItr, typename Node_Itr, typename Cmp_Fn, typename Allocator>
+class tree_order_statistics_node_update {
+public:
+	typedef Node_CItr node_const_iterator;
+	typedef Node_Itr node_iterator;
+	typedef Cmp_Fn cmp_fn;
+	typedef Allocator allocator_type;
+};
+
+} // namespace __gnu_pbds
+
+#endif
+`;
+const assocContainerHeader = String.raw `#ifndef WASM_CLANG_EXT_PB_DS_ASSOC_CONTAINER_HPP
+#define WASM_CLANG_EXT_PB_DS_ASSOC_CONTAINER_HPP
+
+#include <algorithm>
+#include <cstddef>
+#include <functional>
+#include <iterator>
+#include <map>
+#include <memory>
+#include <set>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <ext/pb_ds/tree_policy.hpp>
+
+namespace __gnu_pbds {
+
+namespace detail {
+
+template <typename Allocator, typename Value>
+struct rebind_allocator {
+	typedef typename std::allocator_traits<Allocator>::template rebind_alloc<Value> type;
+};
+
+template <typename Iterator>
+Iterator advance_to_order(Iterator first, Iterator last, std::size_t order) {
+	if (order >= static_cast<std::size_t>(std::distance(first, last))) return last;
+	std::advance(
+		first,
+		static_cast<typename std::iterator_traits<Iterator>::difference_type>(order)
+	);
+	return first;
+}
+
+template <
+	typename Key,
+	typename Mapped,
+	typename Hash_Fn,
+	typename Eq_Fn,
+	typename Allocator
+>
+struct hash_table_selector {
+	typedef std::pair<const Key, Mapped> value_type;
+	typedef typename rebind_allocator<Allocator, value_type>::type allocator_type;
+	typedef std::unordered_map<Key, Mapped, Hash_Fn, Eq_Fn, allocator_type> type;
+};
+
+template <typename Key, typename Hash_Fn, typename Eq_Fn, typename Allocator>
+struct hash_table_selector<Key, null_type, Hash_Fn, Eq_Fn, Allocator> {
+	typedef typename rebind_allocator<Allocator, Key>::type allocator_type;
+	typedef std::unordered_set<Key, Hash_Fn, Eq_Fn, allocator_type> type;
+};
+
+} // namespace detail
+
+template <
+	typename Key,
+	typename Mapped,
+	typename Cmp_Fn = std::less<Key>,
+	typename Tag = rb_tree_tag,
+	template <typename Node_CItr, typename Node_Itr, typename Cmp_Fn_, typename Allocator_>
+	class Node_Update = null_node_update,
+	typename Allocator = std::allocator<char>
+>
+class tree {
+public:
+	typedef Key key_type;
+	typedef Mapped mapped_type;
+	typedef std::pair<const Key, Mapped> value_type;
+	typedef Cmp_Fn cmp_fn;
+	typedef Tag container_category;
+	typedef Allocator allocator_type;
+	typedef std::size_t size_type;
+
+private:
+	typedef typename detail::rebind_allocator<Allocator, value_type>::type value_allocator_type;
+	typedef std::map<Key, Mapped, Cmp_Fn, value_allocator_type> container_type;
+
+public:
+	typedef typename container_type::iterator iterator;
+	typedef typename container_type::const_iterator const_iterator;
+	typedef typename container_type::iterator point_iterator;
+	typedef typename container_type::const_iterator const_point_iterator;
+	typedef typename container_type::reverse_iterator reverse_iterator;
+	typedef typename container_type::const_reverse_iterator const_reverse_iterator;
+
+	tree() = default;
+	explicit tree(const Cmp_Fn& compare) : values_(compare) {}
+
+	template <typename InputIt>
+	tree(InputIt first, InputIt last) : values_(first, last) {}
+
+	bool empty() const { return values_.empty(); }
+	size_type size() const { return values_.size(); }
+	size_type max_size() const { return values_.max_size(); }
+
+	iterator begin() { return values_.begin(); }
+	const_iterator begin() const { return values_.begin(); }
+	const_iterator cbegin() const { return values_.cbegin(); }
+	iterator end() { return values_.end(); }
+	const_iterator end() const { return values_.end(); }
+	const_iterator cend() const { return values_.cend(); }
+	reverse_iterator rbegin() { return values_.rbegin(); }
+	const_reverse_iterator rbegin() const { return values_.rbegin(); }
+	reverse_iterator rend() { return values_.rend(); }
+	const_reverse_iterator rend() const { return values_.rend(); }
+
+	std::pair<iterator, bool> insert(const value_type& value) { return values_.insert(value); }
+	std::pair<iterator, bool> insert(value_type&& value) { return values_.insert(std::move(value)); }
+
+	template <typename InputIt>
+	void insert(InputIt first, InputIt last) {
+		values_.insert(first, last);
+	}
+
+	mapped_type& operator[](const key_type& key) { return values_[key]; }
+	mapped_type& at(const key_type& key) { return values_.at(key); }
+	const mapped_type& at(const key_type& key) const { return values_.at(key); }
+
+	iterator find(const key_type& key) { return values_.find(key); }
+	const_iterator find(const key_type& key) const { return values_.find(key); }
+	bool contains(const key_type& key) const { return values_.find(key) != values_.end(); }
+	size_type count(const key_type& key) const { return values_.count(key); }
+
+	iterator lower_bound(const key_type& key) { return values_.lower_bound(key); }
+	const_iterator lower_bound(const key_type& key) const { return values_.lower_bound(key); }
+	iterator upper_bound(const key_type& key) { return values_.upper_bound(key); }
+	const_iterator upper_bound(const key_type& key) const { return values_.upper_bound(key); }
+
+	size_type erase(const key_type& key) { return values_.erase(key); }
+	iterator erase(const_iterator position) { return values_.erase(position); }
+	iterator erase(const_iterator first, const_iterator last) { return values_.erase(first, last); }
+	void clear() { values_.clear(); }
+	void swap(tree& other) { values_.swap(other.values_); }
+
+	iterator find_by_order(size_type order) {
+		return detail::advance_to_order(values_.begin(), values_.end(), order);
+	}
+
+	const_iterator find_by_order(size_type order) const {
+		return detail::advance_to_order(values_.begin(), values_.end(), order);
+	}
+
+	size_type order_of_key(const key_type& key) const {
+		return static_cast<size_type>(std::distance(values_.begin(), values_.lower_bound(key)));
+	}
+
+	void join(tree& other) {
+		values_.insert(other.values_.begin(), other.values_.end());
+		other.values_.clear();
+	}
+
+	void split(const key_type& key, tree& other) {
+		iterator first = values_.upper_bound(key);
+		other.values_.insert(first, values_.end());
+		values_.erase(first, values_.end());
+	}
+
+private:
+	container_type values_;
+};
+
+template <
+	typename Key,
+	typename Cmp_Fn,
+	typename Tag,
+	template <typename Node_CItr, typename Node_Itr, typename Cmp_Fn_, typename Allocator_>
+	class Node_Update,
+	typename Allocator
+>
+class tree<Key, null_type, Cmp_Fn, Tag, Node_Update, Allocator> {
+public:
+	typedef Key key_type;
+	typedef null_type mapped_type;
+	typedef Key value_type;
+	typedef Cmp_Fn cmp_fn;
+	typedef Tag container_category;
+	typedef Allocator allocator_type;
+	typedef std::size_t size_type;
+
+private:
+	typedef typename detail::rebind_allocator<Allocator, value_type>::type value_allocator_type;
+	typedef std::set<Key, Cmp_Fn, value_allocator_type> container_type;
+
+public:
+	typedef typename container_type::iterator iterator;
+	typedef typename container_type::const_iterator const_iterator;
+	typedef typename container_type::iterator point_iterator;
+	typedef typename container_type::const_iterator const_point_iterator;
+	typedef typename container_type::reverse_iterator reverse_iterator;
+	typedef typename container_type::const_reverse_iterator const_reverse_iterator;
+
+	tree() = default;
+	explicit tree(const Cmp_Fn& compare) : values_(compare) {}
+
+	template <typename InputIt>
+	tree(InputIt first, InputIt last) : values_(first, last) {}
+
+	bool empty() const { return values_.empty(); }
+	size_type size() const { return values_.size(); }
+	size_type max_size() const { return values_.max_size(); }
+
+	iterator begin() { return values_.begin(); }
+	const_iterator begin() const { return values_.begin(); }
+	const_iterator cbegin() const { return values_.cbegin(); }
+	iterator end() { return values_.end(); }
+	const_iterator end() const { return values_.end(); }
+	const_iterator cend() const { return values_.cend(); }
+	reverse_iterator rbegin() { return values_.rbegin(); }
+	const_reverse_iterator rbegin() const { return values_.rbegin(); }
+	reverse_iterator rend() { return values_.rend(); }
+	const_reverse_iterator rend() const { return values_.rend(); }
+
+	std::pair<iterator, bool> insert(const value_type& value) { return values_.insert(value); }
+	std::pair<iterator, bool> insert(value_type&& value) { return values_.insert(std::move(value)); }
+
+	template <typename InputIt>
+	void insert(InputIt first, InputIt last) {
+		values_.insert(first, last);
+	}
+
+	iterator find(const key_type& key) { return values_.find(key); }
+	const_iterator find(const key_type& key) const { return values_.find(key); }
+	bool contains(const key_type& key) const { return values_.find(key) != values_.end(); }
+	size_type count(const key_type& key) const { return values_.count(key); }
+
+	iterator lower_bound(const key_type& key) { return values_.lower_bound(key); }
+	const_iterator lower_bound(const key_type& key) const { return values_.lower_bound(key); }
+	iterator upper_bound(const key_type& key) { return values_.upper_bound(key); }
+	const_iterator upper_bound(const key_type& key) const { return values_.upper_bound(key); }
+
+	size_type erase(const key_type& key) { return values_.erase(key); }
+	iterator erase(const_iterator position) { return values_.erase(position); }
+	iterator erase(const_iterator first, const_iterator last) { return values_.erase(first, last); }
+	void clear() { values_.clear(); }
+	void swap(tree& other) { values_.swap(other.values_); }
+
+	iterator find_by_order(size_type order) {
+		return detail::advance_to_order(values_.begin(), values_.end(), order);
+	}
+
+	const_iterator find_by_order(size_type order) const {
+		return detail::advance_to_order(values_.begin(), values_.end(), order);
+	}
+
+	size_type order_of_key(const key_type& key) const {
+		return static_cast<size_type>(std::distance(values_.begin(), values_.lower_bound(key)));
+	}
+
+	void join(tree& other) {
+		values_.insert(other.values_.begin(), other.values_.end());
+		other.values_.clear();
+	}
+
+	void split(const key_type& key, tree& other) {
+		iterator first = values_.upper_bound(key);
+		other.values_.insert(first, values_.end());
+		values_.erase(first, values_.end());
+	}
+
+private:
+	container_type values_;
+};
+
+template <
+	typename Key,
+	typename Mapped,
+	typename Hash_Fn = std::hash<Key>,
+	typename Eq_Fn = std::equal_to<Key>,
+	typename Comb_Hash_Fn = void,
+	typename Resize_Policy = void,
+	bool Store_Hash = false,
+	typename Allocator = std::allocator<char>
+>
+using gp_hash_table = typename detail::hash_table_selector<
+	Key,
+	Mapped,
+	Hash_Fn,
+	Eq_Fn,
+	Allocator
+>::type;
+
+template <
+	typename Key,
+	typename Mapped,
+	typename Hash_Fn = std::hash<Key>,
+	typename Eq_Fn = std::equal_to<Key>,
+	typename Comb_Hash_Fn = void,
+	typename Resize_Policy = void,
+	bool Store_Hash = false,
+	typename Allocator = std::allocator<char>
+>
+using cc_hash_table = typename detail::hash_table_selector<
+	Key,
+	Mapped,
+	Hash_Fn,
+	Eq_Fn,
+	Allocator
+>::type;
+
+} // namespace __gnu_pbds
+
+#endif
+`;
+const hashPolicyHeader = String.raw `#ifndef WASM_CLANG_EXT_PB_DS_HASH_POLICY_HPP
+#define WASM_CLANG_EXT_PB_DS_HASH_POLICY_HPP
+
+#include <cstddef>
+
+namespace __gnu_pbds {
+
+template <typename Size_Type = std::size_t>
+class direct_mask_range_hashing {
+public:
+	typedef Size_Type size_type;
+};
+
+template <typename Size_Type = std::size_t>
+class direct_mod_range_hashing {
+public:
+	typedef Size_Type size_type;
+};
+
+template <typename Size_Type = std::size_t>
+class linear_probe_fn {
+public:
+	typedef Size_Type size_type;
+};
+
+template <typename Size_Type = std::size_t>
+class quadratic_probe_fn {
+public:
+	typedef Size_Type size_type;
+};
+
+class hash_exponential_size_policy {};
+class hash_prime_size_policy {};
+
+template <bool External_Load_Access = false, typename Size_Type = std::size_t>
+class hash_load_check_resize_trigger {
+public:
+	typedef Size_Type size_type;
+	explicit hash_load_check_resize_trigger(float = 0.125, float = 0.5) {}
+};
+
+template <bool External_Load_Access = false, typename Size_Type = std::size_t>
+class cc_hash_max_collision_check_resize_trigger {
+public:
+	typedef Size_Type size_type;
+	explicit cc_hash_max_collision_check_resize_trigger(float = 0.5) {}
+};
+
+template <
+	typename Size_Policy = hash_exponential_size_policy,
+	typename Trigger_Policy = hash_load_check_resize_trigger<>,
+	bool External_Size_Access = false,
+	typename Size_Type = std::size_t
+>
+class hash_standard_resize_policy {
+public:
+	typedef Size_Type size_type;
+	hash_standard_resize_policy() = default;
+	explicit hash_standard_resize_policy(const Size_Policy&) {}
+	hash_standard_resize_policy(const Size_Policy&, const Trigger_Policy&) {}
+};
+
+} // namespace __gnu_pbds
+
+#endif
+`;
+const priorityQueueHeader = String.raw `#ifndef WASM_CLANG_EXT_PB_DS_PRIORITY_QUEUE_HPP
+#define WASM_CLANG_EXT_PB_DS_PRIORITY_QUEUE_HPP
+
+#include <algorithm>
+#include <cstddef>
+#include <functional>
+#include <memory>
+#include <queue>
+#include <utility>
+#include <vector>
+
+namespace __gnu_pbds {
+
+struct pairing_heap_tag {};
+struct binary_heap_tag {};
+struct binomial_heap_tag {};
+struct rc_binomial_heap_tag {};
+struct thin_heap_tag {};
+
+namespace detail {
+
+template <typename Allocator, typename Value>
+struct priority_queue_rebind_allocator {
+	typedef typename std::allocator_traits<Allocator>::template rebind_alloc<Value> type;
+};
+
+} // namespace detail
+
+template <
+	typename Value_Type,
+	typename Cmp_Fn = std::less<Value_Type>,
+	typename Tag = pairing_heap_tag,
+	typename Allocator = std::allocator<char>
+>
+class priority_queue {
+public:
+	typedef Value_Type value_type;
+	typedef Cmp_Fn cmp_fn;
+	typedef Tag container_category;
+	typedef Allocator allocator_type;
+	typedef std::size_t size_type;
+	typedef value_type& reference;
+	typedef const value_type& const_reference;
+
+private:
+	typedef typename detail::priority_queue_rebind_allocator<Allocator, value_type>::type value_allocator_type;
+	typedef std::vector<value_type, value_allocator_type> container_type;
+
+public:
+	typedef typename container_type::iterator point_iterator;
+	typedef typename container_type::const_iterator const_point_iterator;
+
+	priority_queue() : values_(), compare_() {
+		std::make_heap(values_.begin(), values_.end(), compare_);
+	}
+
+	explicit priority_queue(const Cmp_Fn& compare) : values_(), compare_(compare) {
+		std::make_heap(values_.begin(), values_.end(), compare_);
+	}
+
+	template <typename InputIt>
+	priority_queue(InputIt first, InputIt last) : values_(first, last), compare_() {
+		std::make_heap(values_.begin(), values_.end(), compare_);
+	}
+
+	bool empty() const { return values_.empty(); }
+	size_type size() const { return values_.size(); }
+	const_reference top() const { return values_.front(); }
+	void clear() { values_.clear(); }
+	void swap(priority_queue& other) {
+		values_.swap(other.values_);
+		std::swap(compare_, other.compare_);
+	}
+
+	point_iterator push(const_reference value) {
+		values_.push_back(value);
+		std::push_heap(values_.begin(), values_.end(), compare_);
+		return values_.empty() ? values_.end() : values_.begin();
+	}
+
+	void pop() {
+		std::pop_heap(values_.begin(), values_.end(), compare_);
+		values_.pop_back();
+	}
+
+	void modify(point_iterator position, const_reference value) {
+		if (position == values_.end()) return;
+		*position = value;
+		std::make_heap(values_.begin(), values_.end(), compare_);
+	}
+
+	void erase(point_iterator position) {
+		if (position == values_.end()) return;
+		values_.erase(position);
+		std::make_heap(values_.begin(), values_.end(), compare_);
+	}
+
+	void join(priority_queue& other) {
+		values_.insert(values_.end(), other.values_.begin(), other.values_.end());
+		other.values_.clear();
+		std::make_heap(values_.begin(), values_.end(), compare_);
+	}
+
+private:
+	container_type values_;
+	Cmp_Fn compare_;
+};
+
+} // namespace __gnu_pbds
+
+#endif
+`;
+const ropeHeader = String.raw `#ifndef WASM_CLANG_EXT_ROPE
+#define WASM_CLANG_EXT_ROPE
+
+#include <algorithm>
+#include <cstddef>
+#include <iosfwd>
+#include <iterator>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <utility>
+
+namespace __gnu_cxx {
+
+template <typename CharT, typename Alloc = std::allocator<CharT>>
+class rope {
+public:
+	typedef CharT value_type;
+	typedef Alloc allocator_type;
+	typedef std::basic_string<CharT, std::char_traits<CharT>, Alloc> string_type;
+	typedef typename string_type::traits_type traits_type;
+	typedef typename string_type::size_type size_type;
+	typedef typename string_type::difference_type difference_type;
+	typedef typename string_type::reference reference;
+	typedef typename string_type::const_reference const_reference;
+	typedef typename string_type::iterator iterator;
+	typedef typename string_type::const_iterator const_iterator;
+
+	static const size_type npos = string_type::npos;
+
+	rope() = default;
+	rope(const rope&) = default;
+	rope(rope&&) = default;
+	rope& operator=(const rope&) = default;
+	rope& operator=(rope&&) = default;
+
+	rope(const CharT* value) : data_(value ? value : empty_c_str()) {}
+	rope(const CharT* value, size_type count) : data_(value, count) {}
+	rope(size_type count, CharT value) : data_(count, value) {}
+	rope(const string_type& value) : data_(value) {}
+	rope(string_type&& value) : data_(std::move(value)) {}
+
+	template <typename InputIt>
+	rope(InputIt first, InputIt last) : data_(first, last) {}
+
+	bool empty() const { return data_.empty(); }
+	size_type size() const { return data_.size(); }
+	size_type length() const { return data_.length(); }
+	size_type max_size() const { return data_.max_size(); }
+	void clear() { data_.clear(); }
+
+	const CharT* c_str() const { return data_.c_str(); }
+	const string_type& str() const { return data_; }
+
+	iterator begin() { return data_.begin(); }
+	const_iterator begin() const { return data_.begin(); }
+	const_iterator cbegin() const { return data_.cbegin(); }
+	iterator end() { return data_.end(); }
+	const_iterator end() const { return data_.end(); }
+	const_iterator cend() const { return data_.cend(); }
+
+	reference operator[](size_type index) { return data_[index]; }
+	const_reference operator[](size_type index) const { return data_[index]; }
+	reference at(size_type index) { return data_.at(index); }
+	const_reference at(size_type index) const { return data_.at(index); }
+	reference mutable_reference_at(size_type index) { return data_.at(index); }
+
+	void push_back(CharT value) { data_.push_back(value); }
+	void pop_back() { data_.pop_back(); }
+
+	rope& append(const rope& value) {
+		data_.append(value.data_);
+		return *this;
+	}
+
+	rope& append(const CharT* value) {
+		data_.append(value ? value : empty_c_str());
+		return *this;
+	}
+
+	rope& append(const CharT* value, size_type count) {
+		data_.append(value, count);
+		return *this;
+	}
+
+	rope& append(size_type count, CharT value) {
+		data_.append(count, value);
+		return *this;
+	}
+
+	rope& insert(size_type position, const rope& value) {
+		data_.insert(position, value.data_);
+		return *this;
+	}
+
+	rope& insert(size_type position, const CharT* value) {
+		data_.insert(position, value ? value : empty_c_str());
+		return *this;
+	}
+
+	rope& insert(size_type position, const CharT* value, size_type count) {
+		data_.insert(position, value, count);
+		return *this;
+	}
+
+	rope& insert(size_type position, size_type count, CharT value) {
+		data_.insert(position, count, value);
+		return *this;
+	}
+
+	rope& erase(size_type position = 0, size_type count = npos) {
+		data_.erase(position, count);
+		return *this;
+	}
+
+	rope& replace(size_type position, size_type count, const rope& value) {
+		data_.replace(position, count, value.data_);
+		return *this;
+	}
+
+	rope& replace(size_type position, size_type count, const CharT* value) {
+		data_.replace(position, count, value ? value : empty_c_str());
+		return *this;
+	}
+
+	rope substr(size_type position = 0, size_type count = npos) const {
+		return rope(data_.substr(position, count));
+	}
+
+	size_type copy(size_type position, size_type count, CharT* target) const {
+		if (position > data_.size()) return 0;
+		const size_type copied = std::min(count, data_.size() - position);
+		traits_type::copy(target, data_.data() + position, copied);
+		return copied;
+	}
+
+	int compare(const rope& value) const { return data_.compare(value.data_); }
+
+	rope& operator+=(const rope& value) { return append(value); }
+	rope& operator+=(const CharT* value) { return append(value); }
+	rope& operator+=(CharT value) {
+		push_back(value);
+		return *this;
+	}
+
+private:
+	static const CharT* empty_c_str() {
+		static const CharT empty[1] = {};
+		return empty;
+	}
+
+	string_type data_;
+};
+
+template <typename CharT, typename Alloc>
+rope<CharT, Alloc> operator+(rope<CharT, Alloc> left, const rope<CharT, Alloc>& right) {
+	left += right;
+	return left;
+}
+
+template <typename CharT, typename Alloc>
+bool operator==(const rope<CharT, Alloc>& left, const rope<CharT, Alloc>& right) {
+	return left.compare(right) == 0;
+}
+
+template <typename CharT, typename Alloc>
+bool operator!=(const rope<CharT, Alloc>& left, const rope<CharT, Alloc>& right) {
+	return !(left == right);
+}
+
+template <typename CharT, typename Alloc>
+bool operator<(const rope<CharT, Alloc>& left, const rope<CharT, Alloc>& right) {
+	return left.compare(right) < 0;
+}
+
+template <typename CharT, typename Alloc>
+std::basic_ostream<CharT>& operator<<(
+	std::basic_ostream<CharT>& output,
+	const rope<CharT, Alloc>& value
+) {
+	return output << value.str();
+}
+
+typedef rope<char> crope;
+typedef rope<wchar_t> wrope;
+
+} // namespace __gnu_cxx
+
+#endif
+`;
+const bitsExtcxxHeader = String.raw `#ifndef WASM_CLANG_BITS_EXTCXX_H
+#define WASM_CLANG_BITS_EXTCXX_H
+
+#include <bits/stdc++.h>
+#include <ext/hash_map>
+#include <ext/hash_set>
+#include <ext/rope>
+#include <ext/pb_ds/assoc_container.hpp>
+#include <ext/pb_ds/hash_policy.hpp>
+#include <ext/pb_ds/priority_queue.hpp>
+#include <ext/pb_ds/tree_policy.hpp>
+
+#endif
+`;
+export const GCC_COMPATIBILITY_HEADERS = [
+    {
+        path: 'include/bits/extc++.h',
+        contents: bitsExtcxxHeader
+    },
+    {
+        path: 'include/c++/v1/ext/rope',
+        contents: ropeHeader
+    },
+    {
+        path: 'include/c++/v1/ext/pb_ds/tree_policy.hpp',
+        contents: treePolicyHeader
+    },
+    {
+        path: 'include/c++/v1/ext/pb_ds/assoc_container.hpp',
+        contents: assocContainerHeader
+    },
+    {
+        path: 'include/c++/v1/ext/pb_ds/hash_policy.hpp',
+        contents: hashPolicyHeader
+    },
+    {
+        path: 'include/c++/v1/ext/pb_ds/priority_queue.hpp',
+        contents: priorityQueueHeader
+    }
+];
+const gccCompatibilityDirectories = ['include/c++/v1/ext/pb_ds', 'include/bits'];
+const joinRootPath = (root, path) => {
+    const normalizedRoot = root.replace(/\/+$/, '');
+    const normalizedPath = path.replace(/^\/+/, '');
+    return normalizedRoot ? `${normalizedRoot}/${normalizedPath}` : normalizedPath;
+};
+export function installGccCompatibilityHeaders(memfs) {
+    memfs.addDirectory('include/c++/v1/ext/pb_ds');
+    for (const header of GCC_COMPATIBILITY_HEADERS) {
+        memfs.addFile(header.path, header.contents);
+    }
+}
+export function writeGccCompatibilityHeaders(fs, root = '') {
+    for (const directory of gccCompatibilityDirectories) {
+        fs.mkdirTree(joinRootPath(root, directory));
+    }
+    for (const header of GCC_COMPATIBILITY_HEADERS) {
+        fs.writeFile(joinRootPath(root, header.path), header.contents);
+    }
+}