checkpoint

2026-10-20 00:17:43 +00:00 · 2020-11-08 22:32:36 -05:00
983 changed files with 26144 additions and 111793 deletions
@@ -1,133 +1,112 @@
-linux_task:
-  name: "alpine:latest"
-  container:
-    image: alpine:latest
-    cpu: 4
-    memory: 4G
-  timeout_in: 15m
+freebsd_task:
+  name: "freebsd:12.1"
+  freebsd_instance:
+    image_family: freebsd-12-1
+  env:
+    ASSUME_ALWAYS_YES: yes
  script:
-    - buildtools/install-build-pkgs
+    - tools/install-build-pkgs
+    - gmake -j4
+
+#macos_task:
+#  osx_instance:
+#    image: catalina-base
+#  script:
+#    - tools/install-build-pkgs
+#    - gmake -j4
+
+linux_task:
+  name: "alpine:3.11"
+  container:
+    image: alpine:3.11
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
    - make STATIC=1 LTO=1

 linux_task:
-  name: "alpine-arm:latest"
-  arm_container:
-    image: alpine:latest
-    cpu: 4
-    memory: 4G
-  timeout_in: 15m
-  script:
-    - buildtools/install-build-pkgs
-    - make STATIC=1 LTO=1
-
-linux_task:
-  name: "fedora:41"
+  name: "centos:6"
  container:
-    image: fedora:41
+    image: centos:6
    cpu: 4
-    memory: 4G
-  timeout_in: 15m
+    memory: 2G
+  timeout_in: 10m
  script:
-    - buildtools/install-build-pkgs
+    - tools/install-build-pkgs
    - make
    - make rpm

 linux_task:
-  name: "fedora-arm:41"
-  arm_container:
-    image: fedora:41
+  name: "centos:7"
+  container:
+    image: centos:7
    cpu: 4
-    memory: 4G
-  timeout_in: 15m
+    memory: 2G
+  timeout_in: 10m
  script:
-    - buildtools/install-build-pkgs
+    - tools/install-build-pkgs
    - make
    - make rpm

 linux_task:
-  name: "ubuntu:22.04"
+  name: "centos:8"
  container:
-    image: ubuntu:22.04
+    image: centos:8
    cpu: 4
-    memory: 4G
-  timeout_in: 15m
+    memory: 2G
+  timeout_in: 10m
  script:
-    - buildtools/install-build-pkgs
-    - git fetch
-    - make deb
-    - apt-get -y install fuse
-    - dpkg -i ../*.deb
-    - mergerfs -v || true
+    - tools/install-build-pkgs
+    - make
+    - make rpm

 linux_task:
-  name: "ubuntu:24.04"
+  name: "fedora:30"
  container:
-    image: ubuntu:24.04
+    image: fedora:30
    cpu: 4
-    memory: 4G
-  timeout_in: 15m
+    memory: 2G
+  timeout_in: 10m
  script:
-    - buildtools/install-build-pkgs
-    - git fetch
-    - make deb
-    - apt-get -y install fuse
-    - dpkg -i ../*.deb
-    - mergerfs -v || true
+    - tools/install-build-pkgs
+    - make
+    - make rpm

 linux_task:
-  name: "ubuntu:latest"
+  name: "fedora:31"
  container:
-    image: ubuntu:latest
+    image: fedora:31
    cpu: 4
-    memory: 4G
-  timeout_in: 15m
+    memory: 2G
+  timeout_in: 10m
  script:
-    - buildtools/install-build-pkgs
-    - git fetch
-    - make deb
-    - apt-get -y install fuse
-    - dpkg -i ../*.deb
-    - mergerfs -v || true
+    - tools/install-build-pkgs
+    - make
+    - make rpm

 linux_task:
-  name: "ubuntu-arm:latest"
-  arm_container:
-    image: ubuntu:latest
-    cpu: 4
-    memory: 4G
-  timeout_in: 15m
-  script:
-    - buildtools/install-build-pkgs
-    - git fetch
-    - make deb
-    - apt-get -y install fuse
-    - dpkg -i ../*.deb
-    - mergerfs -v || true
-
-linux_task:
-  name: "debian:12"
+  name: "fedora:32"
  container:
-    image: debian:12
+    image: fedora:32
    cpu: 4
-    memory: 4G
-  timeout_in: 15m
+    memory: 2G
+  timeout_in: 10m
  script:
-    - buildtools/install-build-pkgs
-    - git fetch
-    - make deb
-    - apt-get -y install fuse
-    - dpkg -i ../*.deb
-    - mergerfs -v || true
+    - tools/install-build-pkgs
+    - make
+    - make rpm

 linux_task:
-  name: "debian:latest"
+  name: "ubuntu:14.04"
  container:
-    image: debian:latest
+    image: ubuntu:14.04
    cpu: 4
-    memory: 4G
-  timeout_in: 15m
+    memory: 2G
+  timeout_in: 10m
  script:
-    - buildtools/install-build-pkgs
+    - tools/install-build-pkgs
    - git fetch
    - make deb
    - apt-get -y install fuse
@@ -135,14 +114,119 @@ linux_task:
    - mergerfs -v || true

 linux_task:
-  name: "debian-arm:latest"
-  arm_container:
-    image: debian:latest
+  name: "ubuntu:16.04"
+  container:
+    image: ubuntu:16.04
    cpu: 4
-    memory: 4G
-  timeout_in: 15m
+    memory: 2G
+  timeout_in: 10m
  script:
-    - buildtools/install-build-pkgs
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "ubuntu:18.04"
+  container:
+    image: ubuntu:18.04
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "ubuntu:19.10"
+  container:
+    image: ubuntu:19.10
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "ubuntu:20.04"
+  container:
+    image: ubuntu:20.04
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "debian:7"
+  container:
+    image: debian:8
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "debian:8"
+  container:
+    image: debian:8
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "debian:9"
+  container:
+    image: debian:9
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "debian:10"
+  container:
+    image: debian:10
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
    - git fetch
    - make deb
    - apt-get -y install fuse
@@ -1,2 +1,7 @@
+# These are supported funding model platforms
+
 github: [trapexit]
-custom: ['https://github.com/trapexit/support']
+patreon: trapexit
+open_collective: trapexit
+ko_fi: trapexit
+custom: ['https://paypal.me/trapexit','https://www.subscribestar.com/trapexit']
@@ -8,42 +8,27 @@ assignees: ''
 ---

 **Describe the bug**
-
-A clear and concise description of the unexpected behavior.
-
-**Please be sure to use latest release of mergerfs to ensure the issue still exists. Not your distro's latest but the latest official release.**
-
-The master branch is **not** to be considered production ready. Feel free to file bug reports but do so indicating clearly that you are testing unreleased code.
-
+A clear and concise description of what the bug is. Please do not file bugs for unreleased versions unless you're a tester or sure it's not a work in progress. The master branch is **not** to be considered in a production state.

 **To Reproduce**
-
 Steps to reproduce the behavior. List **all** steps to reproduce. **All** settings.

-Please simplify the reproduction as much as possible.
+Please simplify the reproduction as much as possible. 
 - Unless it is dependenat on multiple branches, use a single branch
- - Reproduce with standard tooling if possible (touch,truncate,rm,rmdir,ln,etc.) Having to install 3rd party software will make debugging more difficult.
+ - Use basic tooling if possible (touch,truncate,rm,rmdir,ln,etc.)


 **Expected behavior**
-
-A clear and concise description of the expected behavior.
+A clear and concise description of what you expected to happen.


 **System information:**
-
 - OS, kernel version: `uname -a`
 - mergerfs version: `mergerfs -V`
 - mergerfs settings
- - List of drives, filesystems, & sizes:
-   - `df -h`
-   - `lsblk -f`
- - A strace of the application having a problem:
-   - `strace -fvTtt -s 256 -o /tmp/app.strace.txt <cmd>`
-   - `strace -fvTtt -s 256 -o /tmp/app.strace.txt -p <appPID>`
- - strace of mergerfs while app tried to do it's thing:
-   - `strace -fvTtt -s 256 -p <mergerfsPID> -o /tmp/mergerfs.strace.txt`
+ - List of drives, filesystems, & sizes: `df -h`
+ - A strace of the application having a problem: `strace -f -o /tmp/app.strace.txt <cmd>` or `strace -f -p <appPID> -o /tmp/app.strace.txt`
+ - strace of mergerfs while app tried to do it's thing: `strace -f -p <mergerfsPID> -o /tmp/mergerfs.strace.txt`

 **Additional context**
-
 Add any other context about the problem here.
@@ -1,10 +1,10 @@
 ---
 name: Question
-about: When you're looking for information or general support
+about: When you're looking for information
 title: ''
 labels: investigating, question
 assignees: ''

 ---

-For general questions and support please use [GitHub Discussions](https://github.com/trapexit/mergerfs/discussions) or [Discord](https://discord.gg/MpAr69V).
+You can also ask questions on Discord for realtime help: https://discord.gg/MpAr69V
@@ -1,42 +0,0 @@
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ "master" ]
-  pull_request:
-    branches: [ "master" ]
-  schedule:
-    - cron: "7 3 * * 6"
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ python, cpp ]
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v2
-        with:
-          languages: ${{ matrix.language }}
-          queries: +security-and-quality
-
-      - name: Autobuild
-        uses: github/codeql-action/autobuild@v2
-        if: ${{ matrix.language == 'python' || matrix.language == 'cpp' }}
-
-      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v2
-        with:
-          category: "/language:${{ matrix.language }}"
@@ -1,49 +0,0 @@
-name: "mkdocs"
-on:
-  push:
-    branches:
-      - master
-    tags:
-      - '*'
-
-permissions:
-  contents: write
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v4
-
-      - name: Setup Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.x'
-
-      - name: Configure Git Credentials
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
-
-      - name: Install dependencies
-        working-directory: ./mkdocs
-        run: |
-          pip install --no-cache-dir mkdocs mkdocs-material pymdown-extensions mike
-
-      - name: Deploy docs
-        working-directory: ./mkdocs
-        env:
-          REF_TYPE: ${{ github.ref_type }}
-          REF_NAME: ${{ github.ref_name }}
-        run: |
-          if [ "$REF_TYPE" = "tag" ]; then
-            mike deploy "$REF_NAME" "latest" --allow-empty --ignore-remote-status --update-aliases
-            mike set-default "latest"
-            #git checkout gh-pages
-            #git push -f origin gh-pages
-          elif [ "$REF_TYPE" = "branch" ] && [ "$REF_NAME" = "master" ]; then
-            mike deploy "master" --ignore-remote-status --allow-empty
-            #git checkout gh-pages
-            #git push -f origin gh-pages
-          fi
@@ -23,7 +23,3 @@ debian/changelog

 # RPM files
 rpmbuild/
-
-# mkdocs files
-mkdocs/venv
-__pycache__/
@@ -0,0 +1,44 @@
+language: cpp
+
+matrix:
+  include:
+    - os: linux
+      dist: precise
+      compiler: gcc
+      sudo: required
+    - os: linux
+      dist: precise
+      compiler: clang
+      sudo: required
+    - os: linux
+      dist: trusty
+      compiler: gcc
+      sudo: required
+    - os: linux
+      dist: trusty
+      compiler: clang
+      sudo: required
+    - os: linux
+      dist: xenial
+      compiler: gcc
+      sudo: required
+    - os: linux
+      dist: xenial
+      compiler: clang
+      sudo: required
+    - os: linux
+      dist: bionic
+      compiler: gcc
+      sudo: required
+    - os: linux
+      dist: bionic
+      compiler: clang
+      sudo: required
+
+script:
+  - sudo -E apt-get install fakeroot
+  - sudo -E make install-build-pkgs
+  - make -j$(($(nproc) + 1))
+  - make deb
+  - sudo -E dpkg -i ../*.deb
+  - mergerfs -v || true
@@ -1,16 +0,0 @@
-## Libraries
-
-### included in repo
-
-* libfuse: https://github.com/libfuse/libfuse (heavily modified fork of v2.x)
-* rapidhash: https://github.com/Nicoshev/rapidhash
-* fmt: https://github.com/fmtlib/fmt
-* concurrentqueue: https://github.com/cameron314/concurrentqueue
-* scope_guard: https://github.com/Neargye/scope_guard
-* subprocess: https://github.com/arun11299/cpp-subprocess
-* CLI11: https://github.com/CLIUtils/CLI11
-* boost
-  * download boost
-  * ./bootstrap.sh
-  * ./b2 tools/bcp
-  * ./dist/bin/bcp unordered/concurrent_flat_map.hpp <target_dir>
@@ -1,7 +1,7 @@
 /*
  ISC License

-  Copyright (c) 2024, Antonio SJ Musumeci <trapexit@spawn.link>
+  Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>

  Permission to use, copy, modify, and/or distribute this software for any
  purpose with or without fee is hereby granted, provided that the above
@@ -1,4 +1,4 @@
-#  Copyright (c) 2024, Antonio SJ Musumeci <trapexit@spawn.link>
+#  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 #
 #  Permission to use, copy, modify, and/or distribute this software for any
 #  purpose with or without fee is hereby granted, provided that the above
@@ -22,9 +22,11 @@ LN        = ln
 FIND 	  = find
 INSTALL   = install
 MKTEMP    = mktemp
-STRIP    ?= strip
+STRIP     = strip
+PANDOC    = pandoc
 SED       = sed
-GIT2DEBCL = ./buildtools/git2debcl
+RPMBUILD  = rpmbuild
+GIT2DEBCL = ./tools/git2debcl
 PKGCONFIG = pkg-config

 GIT_REPO = 0
@@ -37,10 +39,10 @@ endif
 USE_XATTR = 1
 UGID_USE_RWLOCK = 0

-ifeq ($(NDEBUG),1)
-OPT_FLAGS := -O2 -DNDEBUG
+ifeq ($(DEBUG),1)
+OPT_FLAGS := -O0 -g
 else
-OPT_FLAGS := -O0 -DDEBUG -g
+OPT_FLAGS := -O2
 endif

 ifeq ($(STATIC),1)
@@ -56,47 +58,31 @@ LTO_FLAGS :=
 endif

 SRC	    = $(wildcard src/*.cpp)
-OBJS        = $(SRC:src/%.cpp=build/.src/%.o)
-DEPS        = $(SRC:src/%.cpp=build/.src/%.d)
-
-TESTS       = $(wildcard tests/*.cpp)
-TESTS_OBJS  = $(filter-out build/.src/mergerfs.o,$(OBJS))
-TESTS_OBJS += $(TESTS:tests/%.cpp=build/.tests/%.o)
-TESTS_DEPS  = $(TESTS:tests/%.cpp=build/.tests/%.d)
-TESTS_DEPS += $(DEPS)
-
+OBJS        = $(SRC:src/%.cpp=build/%.o)
+DEPS        = $(SRC:src/%.cpp=build/%.d)
 MANPAGE     = mergerfs.1
-CFLAGS      ?= ${OPT_FLAGS}
-CFLAGS      := ${CFLAGS} \
-               -Wall \
-               -Wno-unused-result
 CXXFLAGS    ?= ${OPT_FLAGS}
 CXXFLAGS    := \
              ${CXXFLAGS} \
-              -std=c++17 \
+              -std=c++0x \
              $(STATIC_FLAGS) \
              $(LTO_FLAGS) \
-	      -Isrc \
              -Wall \
              -Wno-unused-result \
              -MMD
 FUSE_FLAGS = \
              -Ilibfuse/include \
-              -D_FILE_OFFSET_BITS=64
+              -D_FILE_OFFSET_BITS=64 \
+              -DFUSE_USE_VERSION=29
 MFS_FLAGS  = \
 	      -DUSE_XATTR=$(USE_XATTR) \
 	      -DUGID_USE_RWLOCK=$(UGID_USE_RWLOCK)
-TESTS_FLAGS = \
-              -Isrc \
-              -DTESTS

 LDFLAGS := \
    ${LDFLAGS} \
    -pthread \
-    -lrt \
-    -lstdc++fs
+    -lrt

-# https://www.gnu.org/prep/standards/html_node/Directory-Variables.html
 DESTDIR       =
 PREFIX        = /usr/local
 EXEC_PREFIX   = $(PREFIX)
@@ -104,13 +90,11 @@ DATAROOTDIR   = $(PREFIX)/share
 DATADIR       = $(DATAROOTDIR)
 BINDIR        = $(EXEC_PREFIX)/bin
 SBINDIR       = $(EXEC_PREFIX)/sbin
-LIBDIR        = $(EXEC_PREFIX)/lib
 MANDIR        = $(DATAROOTDIR)/man
 MAN1DIR       = $(MANDIR)/man1

 INSTALLBINDIR  = $(DESTDIR)$(BINDIR)
 INSTALLSBINDIR = $(DESTDIR)$(SBINDIR)
-INSTALLLIBDIR  = $(DESTDIR)$(LIBDIR)/mergerfs
 INSTALLMAN1DIR = $(DESTDIR)$(MAN1DIR)

 .PHONY: all
@@ -126,20 +110,10 @@ help:
 objects: version build/stamp
 	$(MAKE) $(OBJS)

-tests-objects:
-	$(MAKE) $(TESTS_OBJS)
-
 build/mergerfs: libfuse objects
 	$(CXX) $(CXXFLAGS) $(FUSE_FLAGS) $(MFS_FLAGS) $(CPPFLAGS) $(OBJS) -o $@ libfuse/build/libfuse.a $(LDFLAGS)

-build/tests: build/mergerfs tests-objects
-	$(CXX) $(CXXFLAGS) $(TESTS_FLAGS) $(FUSE_FLAGS) $(MFS_FLAGS) $(CPPFLAGS) $(TESTS_OBJS) -o $@ libfuse/build/libfuse.a $(LDFLAGS)
-
 mergerfs: build/mergerfs
-	ln -fs "mergerfs" "build/fsck.mergerfs"
-	ln -fs "mergerfs" "build/mergerfs.collect-info"
-
-tests: build/tests

 changelog:
 ifeq ($(GIT_REPO),1)
@@ -150,23 +124,15 @@ endif

 .PHONY: version
 version:
-	./buildtools/update-version
+	tools/update-version

 build/stamp:
-	$(MKDIR) -p build/.src build/.tests
+	$(MKDIR) -p build
 	$(TOUCH) $@

-build/.src/%.o: src/%.cpp
+build/%.o: src/%.cpp
 	$(CXX) $(CXXFLAGS) $(FUSE_FLAGS) $(MFS_FLAGS) $(CPPFLAGS) -c $< -o $@

-build/.tests/%.o: tests/%.cpp
-	$(CXX) $(CXXFLAGS) $(TESTS_FLAGS) $(FUSE_FLAGS) $(MFS_FLAGS) $(CPPFLAGS) -c $< -o $@
-
-build/preload.so: build/stamp tools/preload.c
-	$(CC) -shared -fPIC $(CFLAGS) $(CPPFLAGS) -o $@ tools/preload.c
-
-preload: build/preload.so
-
 .PHONY: clean
 clean: rpm-clean
 	$(RM) -rf build
@@ -179,26 +145,20 @@ ifeq ($(GIT_REPO),1)
 endif

 .PHONY: install
-install: install-base install-mount-tools install-preload install-man
+install: install-base install-mount-tools install-man

 install-base: build/mergerfs
 	$(MKDIR) -p "$(INSTALLBINDIR)"
-	$(INSTALL) -v -m 0755 "build/mergerfs" "$(INSTALLBINDIR)/mergerfs"
-	ln -s "mergerfs" "${INSTALLBINDIR}/fsck.mergerfs"
-	ln -s "mergerfs" "${INSTALLBINDIR}/mergerfs.collect-info"
+	$(INSTALL) -v -m 0755 build/mergerfs "$(INSTALLBINDIR)/mergerfs"

 install-mount-tools: install-base
 	$(MKDIR) -p "$(INSTALLBINDIR)"
 	$(MAKE) -C libfuse install

-install-man: man/$(MANPAGE)
+install-man: $(MANPAGE)
 	$(MKDIR) -p "$(INSTALLMAN1DIR)"
 	$(INSTALL) -v -m 0644 "man/$(MANPAGE)" "$(INSTALLMAN1DIR)/$(MANPAGE)"

-install-preload: preload
-	$(MKDIR) -p "$(INSTALLLIBDIR)"
-	$(INSTALL) -v -m 444 "build/preload.so" "$(INSTALLLIBDIR)/preload.so"
-
 install-strip: install-base
 	$(STRIP) "$(INSTALLBINDIR)/mergerfs"

@@ -214,8 +174,17 @@ uninstall-mount.mergerfs:
 uninstall-man:
 	$(RM) -f "$(INSTALLMAN1DIR)/$(MANPAGE)"

+$(MANPAGE): README.md
+ifneq ($(shell $(PANDOC) --version 2> /dev/null),)
+	$(PANDOC) -s -t man -o "man/$(MANPAGE)" README.md
+else
+	$(warning "pandoc does not appear available: unable to build manpage")
+endif
+
+man: $(MANPAGE)
+
 .PHONY: tarball
-tarball: changelog version
+tarball: man changelog version
 	$(eval VERSION := $(shell cat VERSION))
 	$(eval VERSION := $(subst -,_,$(VERSION)))
 	$(eval FILENAME := mergerfs-$(VERSION))
@@ -235,14 +204,14 @@ endif
 signed-deb:
 	$(MAKE) distclean
 	$(MAKE) debian-changelog
-	fakeroot dpkg-buildpackage -nc
+	dpkg-source -b .
+	dpkg-buildpackage -nc

 deb:
 	$(MAKE) distclean
 	$(MAKE) debian-changelog
-	fakeroot dpkg-buildpackage -nc -uc -us
-	mkdir -p ./build/pkgs/
-	mv -v ../mergerfs*deb ./build/pkgs/
+	dpkg-source -b .
+	dpkg-buildpackage -nc -uc -us

 .PHONY: rpm-clean
 rpm-clean:
@@ -255,43 +224,15 @@ rpm: tarball
 	$(SED) 's/__VERSION__/$(VERSION)/g' mergerfs.spec > \
 		rpmbuild/SOURCES/mergerfs.spec
 	cp -ar mergerfs-$(VERSION).tar.gz rpmbuild/SOURCES
-	rpmbuild -ba rpmbuild/SOURCES/mergerfs.spec \
+	$(RPMBUILD) -ba rpmbuild/SOURCES/mergerfs.spec \
 		--define "_topdir $(CURDIR)/rpmbuild"

 .PHONY: install-build-pkgs
 install-build-pkgs:
-	./buildtools/install-build-pkgs
+	tools/install-build-pkgs

 .PHONY: libfuse
 libfuse:
-	$(MAKE) NDEBUG=$(NDEBUG) -C libfuse
-
-.PHONY: release release-amd64
-release:
-	./buildtools/build-release \
-		--target=all \
-		--cleanup \
-		--branch=$(shell git branch --show-current)
-release-sample:
-	./buildtools/build-release \
-		--target=debian.12.amd64 \
-		--cleanup \
-		--branch=$(shell git branch --show-current)
-release-amd64:
-	./buildtools/build-release \
-		--target=amd64 \
-		--cleanup \
-		--branch=$(shell git branch --show-current)
-release-arm64:
-	./buildtools/build-release \
-		--target=arm64 \
-		--cleanup \
-		--branch=$(shell git branch --show-current)
-release-static:
-	./buildtools/build-release \
-		--target=static \
-		--cleanup \
-		--branch=$(shell git branch --show-current)
-
+	$(MAKE) DEBUG=$(DEBUG) -C libfuse

 -include $(DEPS)
@@ -1,49 +0,0 @@
-#!/bin/sh
-
-BRANCH="${1:-master}"
-SRCDIR="/tmp/mergerfs"
-
-git clone https://github.com/trapexit/mergerfs "${SRCDIR}" -b "${BRANCH}"
-
-cd "${SRCDIR}"
-
-git log HEAD^1..
-
-mkdir /build
-if [ -e /usr/bin/apt-get ]; then
-    make deb
-    if [ $? -ne 0 ]; then
-        . /etc/lsb-release
-        cp -v /etc/lsb-release "/build/${DISTRIB_ID}.${DISTRIB_CODENAME}.${DISTRIB_RELEASE}.$(arch).FAILED"
-    fi
-    find /tmp/ \
-         -type f \
-         -name "*.deb" \
-         -not -name "*dbgsym*" \
-         -exec cp -v {} /build/ \;
-elif [ -e /usr/bin/dnf ]; then
-    make rpm
-    if [ $? -ne 0 ]; then
-        . /etc/lsb-release
-        cp -v /etc/lsb-release "/build/${DISTRIB_ID}.${DISTRIB_CODENAME}.${DISTRIB_RELEASE}.$(arch).FAILED"
-    fi
-    find /tmp/ \
-         -type f \
-         -name "*.rpm" \
-         -not -name "*sym*" \
-         -not -name "*src.rpm" \
-         -exec cp -v {} /build/ \;
-elif [ -e /usr/bin/yum ]; then
-    . /opt/rh/devtoolset-9/enable
-    make rpm
-    find /tmp/ \
-         -type f \
-         -name "*.rpm" \
-         -not -name "*sym*" \
-         -not -name "*src.rpm" \
-         -exec cp -v {} /build/ \;
-elif [ -e /sbin/apk ]; then
-    echo "NOT YET SUPPORTED"
-elif [ -e /usr/sbin/pkg ]; then
-    echo "NOT YET SUPPORTED"
-fi
@@ -1,111 +0,0 @@
-#!/usr/bin/env python3
-
-import subprocess
-import sys
-import os
-import argparse
-import time
-
-
-def build(containerfile,
-          pkgdirpath,
-          branch):
-    timestamp = time.time_ns()
-    args = ['podman',
-            'build',
-            '--pull=always',
-            '--force-rm',
-            '-o',pkgdirpath,
-            '-f',containerfile,
-            f'--build-arg=BRANCH={branch}',
-            f'--build-arg=BUILD_TIMESTAMP={timestamp}',
-            'buildtools/']
-    print(args)
-    subprocess.run(args)
-
-
-def setup():
-    args = ['sudo',
-            'apt-get',
-            'install',
-            '-fy',
-            'qemu-user-static',
-            'qemu-user-binfmt']
-    print(args)
-    subprocess.run(args)
-
-
-def podman_cleanup():
-    args = ['podman',
-            'system',
-            'prune',
-            '-af']
-    print(args)
-    subprocess.run(args)
-
-
-def parse_args():
-    p = argparse.ArgumentParser()
-    p.add_argument('--target',
-                   default='debian.12.amd64')
-    p.add_argument('--pkgdirpath',
-                   default='build/pkgs/')
-    p.add_argument('--branch',
-                   default='master')
-    p.add_argument('--setup',
-                   required=False,
-                   action='store_true')
-    p.add_argument('--cleanup',
-                   required=False,
-                   action='store_true')
-
-    return p.parse_args()
-
-
-def should_skip(filename):
-    if filename.endswith('~'):
-        return True
-    return False
-
-
-def main():
-    args = parse_args()
-    print(args)
-
-    if args.setup:
-        setup()
-        sys.exit(0)
-
-    containerfiles = []
-    basepath = 'buildtools/containerfiles'
-    if os.path.exists(f'{basepath}/{args.target}'):
-        containerfiles.append(f'{basepath}/{args.target}')
-    elif args.target == 'all':
-        for root,dirnames,filenames in os.walk(basepath):
-            for filename in filenames:
-                if should_skip(filename):
-                    continue                
-                containerfile = f'buildtools/containerfiles/{filename}'
-                containerfiles.append(containerfile)
-    else:
-        for root,dirnames,filenames in os.walk(basepath):
-            for filename in filenames:
-                if args.target not in filename:
-                    continue
-                if should_skip(filename):
-                    continue                
-                containerfile = f'buildtools/containerfiles/{filename}'
-                containerfiles.append(containerfile)
-
-    for containerfile in containerfiles:
-        if args.cleanup:
-            podman_cleanup()
-        build(containerfile,
-              args.pkgdirpath,
-              args.branch)
-
-    sys.exit(0)
-
-
-if __name__ == '__main__':
-    main()
@@ -1,9 +0,0 @@
-FROM --platform=linux/amd64 quay.io/centos/centos:10 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/arm64 quay.io/centos/centos:10 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/amd64 debian:10 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/arm64 debian:10 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/armhf debian:10 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/i386 debian:10 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/amd64 debian:11 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/arm64 debian:11 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/armhf debian:11 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/i386 debian:11 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/amd64 debian:12 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/arm64 debian:12 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/armhf debian:12 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/i386 debian:12 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/amd64 fedora:37 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/arm64 fedora:37 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/armhf fedora:37 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/i386 fedora:37 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/amd64 fedora:38 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/arm64 fedora:38 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/armhf fedora:38 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/i386 fedora:38 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/amd64 fedora:39 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/amd64 fedora:40 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/amd64 fedora:41 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/amd64 fedora:42 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/amd64 rockylinux:8 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/arm64 rockylinux:8 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/armhf rockylinux:8 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/i386 rockylinux:8 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/amd64 rockylinux:9 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/arm64 rockylinux:9 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/armhf rockylinux:9 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/i386 rockylinux:9 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,13 +0,0 @@
-ARG BUILD_TIMESTAMP=0
-FROM --platform=linux/amd64 alpine:latest as build
-COPY install-build-pkgs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BRANCH=master
-RUN git clone https://github.com/trapexit/mergerfs /tmp/mergerfs -b "${BRANCH}"
-WORKDIR /tmp/mergerfs
-RUN make NDEBUG=1 LTO=1 STATIC=1 DESTDIR=/tmp -j$(nproc) install
-RUN mkdir /build
-RUN tar cvfz /build/mergerfs-static-linux_amd64.tar.gz --directory=/tmp usr sbin
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,13 +0,0 @@
-ARG BUILD_TIMESTAMP=0
-FROM --platform=linux/arm64 alpine:latest as build
-COPY install-build-pkgs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BRANCH=master
-RUN git clone https://github.com/trapexit/mergerfs /tmp/mergerfs -b "${BRANCH}"
-WORKDIR /tmp/mergerfs
-RUN make NDEBUG=1 LTO=1 STATIC=1 DESTDIR=/tmp -j$(nproc) install
-RUN mkdir /build
-RUN tar cvfz /build/mergerfs-static-linux_arm64.tar.gz --directory=/tmp usr sbin
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,13 +0,0 @@
-ARG BUILD_TIMESTAMP=0
-FROM --platform=linux/armhf alpine:latest as build
-COPY install-build-pkgs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BRANCH=master
-RUN git clone https://github.com/trapexit/mergerfs /tmp/mergerfs -b "${BRANCH}"
-WORKDIR /tmp/mergerfs
-RUN make NDEBUG=1 LTO=1 STATIC=1 DESTDIR=/tmp -j$(nproc) install
-RUN mkdir /build
-RUN tar cvfz /build/mergerfs-static-linux_armhf.tar.gz --directory=/tmp usr sbin
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,13 +0,0 @@
-ARG BUILD_TIMESTAMP=0
-FROM --platform=linux/i386 alpine:latest as build
-COPY install-build-pkgs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BRANCH=master
-RUN git clone https://github.com/trapexit/mergerfs /tmp/mergerfs -b "${BRANCH}"
-WORKDIR /tmp/mergerfs
-RUN make NDEBUG=1 LTO=1 STATIC=1 DESTDIR=/tmp -j$(nproc) install
-RUN mkdir /build
-RUN tar cvfz /build/mergerfs-static-linux_i386.tar.gz --directory=/tmp usr sbin
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,10 +0,0 @@
-ARG BUILD_TIMESTAMP=0
-FROM --platform=linux/amd64 ubuntu:latest as build
-RUN apt-get update && apt-get install -y makeself
-RUN mkdir -p /tmp/mergerfs/
-RUN --mount=type=bind,src=pkgs,dst=/pkgs ls -lhd /pkgs
-RUN --mount=type=bind,src=pkgs,dst=/pkgs cp -v /pkg/*static*.gz /tmp/mergerfs/
-RUN makeself /tmp/mergerfs/ /build/mergerfs-installer.run "mergerfs" echo "foo"
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,13 +0,0 @@
-FROM debian:buster as tarball
-COPY install-build-pkgs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN git clone https://github.com/trapexit/mergerfs /tmp/mergerfs -b "${BRANCH}"
-RUN cd /tmp/mergerfs && make version tarball
-RUN mkdir /build
-RUN cp -v /tmp/mergerfs/*.tar.gz /build/
-
-
-FROM scratch
-COPY --from=tarball /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/amd64 ubuntu:20.04 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/arm64 ubuntu:20.04 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/armhf ubuntu:20.04 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/i386 ubuntu:20.04 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/amd64 ubuntu:22.04 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/arm64 ubuntu:22.04 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/armhf ubuntu:22.04 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/i386 ubuntu:22.04 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/amd64 ubuntu:24.04 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/arm64 ubuntu:24.04 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/armhf ubuntu:24.04 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,9 +0,0 @@
-FROM --platform=linux/i386 ubuntu:24.04 as build
-COPY install-build-pkgs build-mergerfs /tmp/
-RUN /tmp/install-build-pkgs
-ARG BUILD_TIMESTAMP=0
-ARG BRANCH=master
-RUN /tmp/build-mergerfs $BRANCH
-
-FROM scratch
-COPY --from=build /build/ /
@@ -1,14 +0,0 @@
-#!/bin/sh
-set -x
-
-BASEPATH="/tmp"
-
-for x in $(seq -w 2)
-do
-    FILEPATH="${BASEPATH}/mergerfs-${x}.img"
-    MOUNTPOINT="${BASEPATH}/mergerfs-${x}"
-    truncate -s 1G "${FILEPATH}"
-    mkdir -p "${MOUNTPOINT}"
-    mkfs.ext4 -m0 -L "mergerfs${x}" "${FILEPATH}"
-    sudo mount "${FILEPATH}" "${MOUNTPOINT}"
-done    
@@ -0,0 +1 @@
+9
@@ -2,7 +2,7 @@ Source: mergerfs
 Section: utils
 Priority: optional
 Maintainer: Antonio SJ Musumeci <trapexit@spawn.link>
-Build-Depends: debhelper-compat (= 10)
+Build-Depends: debhelper (>= 8.0.0)
 Standards-Version: 3.9.4
 Homepage: http://github.com/trapexit/mergerfs

@@ -1,13 +1,11 @@
 #!/usr/bin/make -f
 # -*- makefile -*-

+# Uncomment this to turn on verbose mode.
 export DH_VERBOSE=1

 %:
-	dh $@ --parallel --max-parallel=6
-
-override_dh_strip:
-	dh_strip --no-automatic-dbgsym
+	dh $@ --parallel

 override_dh_auto_install:
 	$(MAKE) DESTDIR=$(CURDIR)/debian/mergerfs PREFIX=/usr install
@@ -9,16 +9,10 @@ UTILS :=
 INSTALLUTILS :=
 endif

-ifeq ($(NDEBUG),1)
-OPT_FLAGS := -O2 -DNDEBUG
+ifeq ($(DEBUG),1)
+OPT_FLAGS := -O0 -g
 else
-OPT_FLAGS := -O0 -DDEBUG -g
-endif
-
-ifeq ($(LTO),1)
-LTO_FLAGS := -flto
-else
-LTO_FLAGS :=
+OPT_FLAGS := -O2
 endif

 DESTDIR       =
@@ -37,47 +31,25 @@ INSTALLMAN1DIR = $(DESTDIR)$(MAN1DIR)

 AR ?= ar

-SRC_C = \
+SRC   = \
 	lib/buffer.c \
-	lib/crc32b.c \
-	lib/debug.c \
 	lib/fuse_dirents.c \
+	lib/fuse.c \
+	lib/fuse_kern_chan.c \
+	lib/fuse_loop_mt.c \
 	lib/fuse_lowlevel.c \
+	lib/fuse_mt.c \
 	lib/fuse_opt.c \
 	lib/fuse_session.c \
 	lib/fuse_signals.c \
 	lib/helper.c \
 	lib/mount.c
-SRC_CPP = \
-	lib/fuse.cpp \
-	lib/cpu.cpp \
-	lib/fuse_config.cpp \
-	lib/fuse_loop.cpp \
-	lib/fuse_msgbuf.cpp \
-	lib/pin_threads.cpp \
-	lib/format.cpp \
-	lib/node.cpp \
-	lib/maintenance_thread.cpp
-
-OBJS_C   = $(SRC_C:lib/%.c=build/%.o)
-OBJS_CPP = $(SRC_CPP:lib/%.cpp=build/%.o)
-DEPS_C   = $(SRC_C:lib/%.c=build/%.d)
-DEPS_CPP = $(SRC_CPP:lib/%.cpp=build/%.d)
-CFLAGS ?= \
-	$(OPT_FLAGS)
-CFLAGS := \
-	${CFLAGS} \
-	$(LTO_FLAGS) \
-	-std=gnu99 \
-	-Wall \
-	-pipe \
-	-MMD
+OBJS = $(SRC:lib/%.c=build/%.o)
+DEPS = $(SRC:lib/%.c=build/%.d)
 CXXFLAGS ?= \
 	$(OPT_FLAGS)
 CXXFLAGS := \
-	${CXXFLAGS} \
-	$(LTO_FLAGS) \
-	-std=c++17 \
+    ${CXXFLAGS} \
 	-Wall \
 	-pipe \
 	-MMD
@@ -87,6 +59,8 @@ FUSE_FLAGS = \
 	-Ibuild \
 	-D_REENTRANT \
 	-D_FILE_OFFSET_BITS=64 \
+	-DFUSE_USE_VERSION=29 \
+	-DPACKAGE_VERSION=\"$(VERSION)\" \
 	-DFUSERMOUNT_DIR=\"$(FUSERMOUNT_DIR)\"
 LDFLAGS := \
 	${LDFLAGS} \
@@ -103,27 +77,24 @@ build/stamp:
 	touch $@

 objects: build/config.h
-	$(MAKE) $(OBJS_C) $(OBJS_CPP)
+	$(MAKE) $(OBJS)

 build/libfuse.a: objects
-	${AR} rcs build/libfuse.a $(OBJS_C) $(OBJS_CPP)
+	${AR} rcs build/libfuse.a $(OBJS)

 utils: mergerfs-fusermount mount.mergerfs

 build/mergerfs-fusermount: build/config.h util/fusermount.c lib/mount_util.c
-	$(CC) $(CFLAGS) $(FUSE_FLAGS) -Ilib -o build/mergerfs-fusermount util/fusermount.c lib/mount_util.c
+	$(CXX) $(CXXFLAGS) $(FUSE_FLAGS) -Ilib -o build/mergerfs-fusermount util/fusermount.c lib/mount_util.c

 mergerfs-fusermount: build/mergerfs-fusermount

 build/mount.mergerfs: build/libfuse.a util/mount.mergerfs.c
-	$(CC) $(CFLAGS) $(FUSE_FLAGS) -o build/mount.mergerfs util/mount.mergerfs.c build/libfuse.a $(LDFLAGS)
+	$(CXX) $(CXXFLAGS) $(FUSE_FLAGS) -o build/mount.mergerfs util/mount.mergerfs.c build/libfuse.a $(LDFLAGS)

 mount.mergerfs: build/mount.mergerfs

 build/%.o: lib/%.c
-	$(CC) $(CFLAGS) $(FUSE_FLAGS) -c $< -o $@
-
-build/%.o: lib/%.cpp
 	$(CXX) $(CXXFLAGS) $(FUSE_FLAGS) -c $< -o $@

 clean:
@@ -138,11 +109,11 @@ strip:
 install-utils: mergerfs-fusermount mount.mergerfs strip
 	install -D build/mergerfs-fusermount "$(INSTALLBINDIR)/mergerfs-fusermount"
 	install -D build/mount.mergerfs "$(INSTALLSBINDIR)/mount.mergerfs"
-	chown root:root "$(INSTALLBINDIR)/mergerfs-fusermount"
+	chown root "$(INSTALLBINDIR)/mergerfs-fusermount"
 	chmod u+s "$(INSTALLBINDIR)/mergerfs-fusermount"

 install: $(INSTALLUTILS)

 .PHONY: objects strip utils install install-utils

-include $(DEPS_C) $(DEPS_CPP)
+-include $(DEPS)
@@ -1,7 +0,0 @@
-#include <malloc.h>
-
-int
-main()
-{
-  malloc_trim(0);
-}
@@ -0,0 +1,11 @@
+#define _GNU_SOURCE
+#include <fcntl.h>
+
+int
+main(int   argc,
+     char *argv[])
+{
+  (void)splice;
+
+  return 0;
+}
@@ -0,0 +1,12 @@
+#define _GNU_SOURCE
+#include <fcntl.h>
+#include <sys/uio.h>
+
+int
+main(int   argc,
+     char *argv[])
+{
+  (void)vmsplice;
+
+  return 0;
+}
@@ -1,220 +0,0 @@
-// Formatting library for C++ - dynamic argument lists
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_ARGS_H_
-#define FMT_ARGS_H_
-
-#ifndef FMT_MODULE
-#  include <functional>  // std::reference_wrapper
-#  include <memory>      // std::unique_ptr
-#  include <vector>
-#endif
-
-#include "format.h"  // std_string_view
-
-FMT_BEGIN_NAMESPACE
-namespace detail {
-
-template <typename T> struct is_reference_wrapper : std::false_type {};
-template <typename T>
-struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
-
-template <typename T> auto unwrap(const T& v) -> const T& { return v; }
-template <typename T>
-auto unwrap(const std::reference_wrapper<T>& v) -> const T& {
-  return static_cast<const T&>(v);
-}
-
-// node is defined outside dynamic_arg_list to workaround a C2504 bug in MSVC
-// 2022 (v17.10.0).
-//
-// Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
-// templates it doesn't complain about inability to deduce single translation
-// unit for placing vtable. So node is made a fake template.
-template <typename = void> struct node {
-  virtual ~node() = default;
-  std::unique_ptr<node<>> next;
-};
-
-class dynamic_arg_list {
-  template <typename T> struct typed_node : node<> {
-    T value;
-
-    template <typename Arg>
-    FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {}
-
-    template <typename Char>
-    FMT_CONSTEXPR typed_node(const basic_string_view<Char>& arg)
-        : value(arg.data(), arg.size()) {}
-  };
-
-  std::unique_ptr<node<>> head_;
-
- public:
-  template <typename T, typename Arg> auto push(const Arg& arg) -> const T& {
-    auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
-    auto& value = new_node->value;
-    new_node->next = std::move(head_);
-    head_ = std::move(new_node);
-    return value;
-  }
-};
-}  // namespace detail
-
-/**
- * A dynamic list of formatting arguments with storage.
- *
- * It can be implicitly converted into `fmt::basic_format_args` for passing
- * into type-erased formatting functions such as `fmt::vformat`.
- */
-template <typename Context> class dynamic_format_arg_store {
- private:
-  using char_type = typename Context::char_type;
-
-  template <typename T> struct need_copy {
-    static constexpr detail::type mapped_type =
-        detail::mapped_type_constant<T, char_type>::value;
-
-    enum {
-      value = !(detail::is_reference_wrapper<T>::value ||
-                std::is_same<T, basic_string_view<char_type>>::value ||
-                std::is_same<T, detail::std_string_view<char_type>>::value ||
-                (mapped_type != detail::type::cstring_type &&
-                 mapped_type != detail::type::string_type &&
-                 mapped_type != detail::type::custom_type))
-    };
-  };
-
-  template <typename T>
-  using stored_t = conditional_t<
-      std::is_convertible<T, std::basic_string<char_type>>::value &&
-          !detail::is_reference_wrapper<T>::value,
-      std::basic_string<char_type>, T>;
-
-  // Storage of basic_format_arg must be contiguous.
-  std::vector<basic_format_arg<Context>> data_;
-  std::vector<detail::named_arg_info<char_type>> named_info_;
-
-  // Storage of arguments not fitting into basic_format_arg must grow
-  // without relocation because items in data_ refer to it.
-  detail::dynamic_arg_list dynamic_args_;
-
-  friend class basic_format_args<Context>;
-
-  auto data() const -> const basic_format_arg<Context>* {
-    return named_info_.empty() ? data_.data() : data_.data() + 1;
-  }
-
-  template <typename T> void emplace_arg(const T& arg) {
-    data_.emplace_back(arg);
-  }
-
-  template <typename T>
-  void emplace_arg(const detail::named_arg<char_type, T>& arg) {
-    if (named_info_.empty())
-      data_.insert(data_.begin(), basic_format_arg<Context>(nullptr, 0));
-    data_.emplace_back(detail::unwrap(arg.value));
-    auto pop_one = [](std::vector<basic_format_arg<Context>>* data) {
-      data->pop_back();
-    };
-    std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)>
-        guard{&data_, pop_one};
-    named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)});
-    data_[0] = {named_info_.data(), named_info_.size()};
-    guard.release();
-  }
-
- public:
-  constexpr dynamic_format_arg_store() = default;
-
-  operator basic_format_args<Context>() const {
-    return basic_format_args<Context>(data(), static_cast<int>(data_.size()),
-                                      !named_info_.empty());
-  }
-
-  /**
-   * Adds an argument into the dynamic store for later passing to a formatting
-   * function.
-   *
-   * Note that custom types and string types (but not string views) are copied
-   * into the store dynamically allocating memory if necessary.
-   *
-   * **Example**:
-   *
-   *     fmt::dynamic_format_arg_store<fmt::format_context> store;
-   *     store.push_back(42);
-   *     store.push_back("abc");
-   *     store.push_back(1.5f);
-   *     std::string result = fmt::vformat("{} and {} and {}", store);
-   */
-  template <typename T> void push_back(const T& arg) {
-    if (detail::const_check(need_copy<T>::value))
-      emplace_arg(dynamic_args_.push<stored_t<T>>(arg));
-    else
-      emplace_arg(detail::unwrap(arg));
-  }
-
-  /**
-   * Adds a reference to the argument into the dynamic store for later passing
-   * to a formatting function.
-   *
-   * **Example**:
-   *
-   *     fmt::dynamic_format_arg_store<fmt::format_context> store;
-   *     char band[] = "Rolling Stones";
-   *     store.push_back(std::cref(band));
-   *     band[9] = 'c'; // Changing str affects the output.
-   *     std::string result = fmt::vformat("{}", store);
-   *     // result == "Rolling Scones"
-   */
-  template <typename T> void push_back(std::reference_wrapper<T> arg) {
-    static_assert(
-        need_copy<T>::value,
-        "objects of built-in types and string views are always copied");
-    emplace_arg(arg.get());
-  }
-
-  /**
-   * Adds named argument into the dynamic store for later passing to a
-   * formatting function. `std::reference_wrapper` is supported to avoid
-   * copying of the argument. The name is always copied into the store.
-   */
-  template <typename T>
-  void push_back(const detail::named_arg<char_type, T>& arg) {
-    const char_type* arg_name =
-        dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();
-    if (detail::const_check(need_copy<T>::value)) {
-      emplace_arg(
-          fmt::arg(arg_name, dynamic_args_.push<stored_t<T>>(arg.value)));
-    } else {
-      emplace_arg(fmt::arg(arg_name, arg.value));
-    }
-  }
-
-  /// Erase all elements from the store.
-  void clear() {
-    data_.clear();
-    named_info_.clear();
-    dynamic_args_ = {};
-  }
-
-  /// Reserves space to store at least `new_cap` arguments including
-  /// `new_cap_named` named arguments.
-  void reserve(size_t new_cap, size_t new_cap_named) {
-    FMT_ASSERT(new_cap >= new_cap_named,
-               "set of arguments includes set of named arguments");
-    data_.reserve(new_cap);
-    named_info_.reserve(new_cap_named);
-  }
-
-  /// Returns the number of elements in the store.
-  size_t size() const noexcept { return data_.size(); }
-};
-
-FMT_END_NAMESPACE
-
-#endif  // FMT_ARGS_H_
@@ -1,637 +0,0 @@
-// Formatting library for C++ - color support
-//
-// Copyright (c) 2018 - present, Victor Zverovich and fmt contributors
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_COLOR_H_
-#define FMT_COLOR_H_
-
-#include "format.h"
-
-FMT_BEGIN_NAMESPACE
-FMT_BEGIN_EXPORT
-
-enum class color : uint32_t {
-  alice_blue = 0xF0F8FF,               // rgb(240,248,255)
-  antique_white = 0xFAEBD7,            // rgb(250,235,215)
-  aqua = 0x00FFFF,                     // rgb(0,255,255)
-  aquamarine = 0x7FFFD4,               // rgb(127,255,212)
-  azure = 0xF0FFFF,                    // rgb(240,255,255)
-  beige = 0xF5F5DC,                    // rgb(245,245,220)
-  bisque = 0xFFE4C4,                   // rgb(255,228,196)
-  black = 0x000000,                    // rgb(0,0,0)
-  blanched_almond = 0xFFEBCD,          // rgb(255,235,205)
-  blue = 0x0000FF,                     // rgb(0,0,255)
-  blue_violet = 0x8A2BE2,              // rgb(138,43,226)
-  brown = 0xA52A2A,                    // rgb(165,42,42)
-  burly_wood = 0xDEB887,               // rgb(222,184,135)
-  cadet_blue = 0x5F9EA0,               // rgb(95,158,160)
-  chartreuse = 0x7FFF00,               // rgb(127,255,0)
-  chocolate = 0xD2691E,                // rgb(210,105,30)
-  coral = 0xFF7F50,                    // rgb(255,127,80)
-  cornflower_blue = 0x6495ED,          // rgb(100,149,237)
-  cornsilk = 0xFFF8DC,                 // rgb(255,248,220)
-  crimson = 0xDC143C,                  // rgb(220,20,60)
-  cyan = 0x00FFFF,                     // rgb(0,255,255)
-  dark_blue = 0x00008B,                // rgb(0,0,139)
-  dark_cyan = 0x008B8B,                // rgb(0,139,139)
-  dark_golden_rod = 0xB8860B,          // rgb(184,134,11)
-  dark_gray = 0xA9A9A9,                // rgb(169,169,169)
-  dark_green = 0x006400,               // rgb(0,100,0)
-  dark_khaki = 0xBDB76B,               // rgb(189,183,107)
-  dark_magenta = 0x8B008B,             // rgb(139,0,139)
-  dark_olive_green = 0x556B2F,         // rgb(85,107,47)
-  dark_orange = 0xFF8C00,              // rgb(255,140,0)
-  dark_orchid = 0x9932CC,              // rgb(153,50,204)
-  dark_red = 0x8B0000,                 // rgb(139,0,0)
-  dark_salmon = 0xE9967A,              // rgb(233,150,122)
-  dark_sea_green = 0x8FBC8F,           // rgb(143,188,143)
-  dark_slate_blue = 0x483D8B,          // rgb(72,61,139)
-  dark_slate_gray = 0x2F4F4F,          // rgb(47,79,79)
-  dark_turquoise = 0x00CED1,           // rgb(0,206,209)
-  dark_violet = 0x9400D3,              // rgb(148,0,211)
-  deep_pink = 0xFF1493,                // rgb(255,20,147)
-  deep_sky_blue = 0x00BFFF,            // rgb(0,191,255)
-  dim_gray = 0x696969,                 // rgb(105,105,105)
-  dodger_blue = 0x1E90FF,              // rgb(30,144,255)
-  fire_brick = 0xB22222,               // rgb(178,34,34)
-  floral_white = 0xFFFAF0,             // rgb(255,250,240)
-  forest_green = 0x228B22,             // rgb(34,139,34)
-  fuchsia = 0xFF00FF,                  // rgb(255,0,255)
-  gainsboro = 0xDCDCDC,                // rgb(220,220,220)
-  ghost_white = 0xF8F8FF,              // rgb(248,248,255)
-  gold = 0xFFD700,                     // rgb(255,215,0)
-  golden_rod = 0xDAA520,               // rgb(218,165,32)
-  gray = 0x808080,                     // rgb(128,128,128)
-  green = 0x008000,                    // rgb(0,128,0)
-  green_yellow = 0xADFF2F,             // rgb(173,255,47)
-  honey_dew = 0xF0FFF0,                // rgb(240,255,240)
-  hot_pink = 0xFF69B4,                 // rgb(255,105,180)
-  indian_red = 0xCD5C5C,               // rgb(205,92,92)
-  indigo = 0x4B0082,                   // rgb(75,0,130)
-  ivory = 0xFFFFF0,                    // rgb(255,255,240)
-  khaki = 0xF0E68C,                    // rgb(240,230,140)
-  lavender = 0xE6E6FA,                 // rgb(230,230,250)
-  lavender_blush = 0xFFF0F5,           // rgb(255,240,245)
-  lawn_green = 0x7CFC00,               // rgb(124,252,0)
-  lemon_chiffon = 0xFFFACD,            // rgb(255,250,205)
-  light_blue = 0xADD8E6,               // rgb(173,216,230)
-  light_coral = 0xF08080,              // rgb(240,128,128)
-  light_cyan = 0xE0FFFF,               // rgb(224,255,255)
-  light_golden_rod_yellow = 0xFAFAD2,  // rgb(250,250,210)
-  light_gray = 0xD3D3D3,               // rgb(211,211,211)
-  light_green = 0x90EE90,              // rgb(144,238,144)
-  light_pink = 0xFFB6C1,               // rgb(255,182,193)
-  light_salmon = 0xFFA07A,             // rgb(255,160,122)
-  light_sea_green = 0x20B2AA,          // rgb(32,178,170)
-  light_sky_blue = 0x87CEFA,           // rgb(135,206,250)
-  light_slate_gray = 0x778899,         // rgb(119,136,153)
-  light_steel_blue = 0xB0C4DE,         // rgb(176,196,222)
-  light_yellow = 0xFFFFE0,             // rgb(255,255,224)
-  lime = 0x00FF00,                     // rgb(0,255,0)
-  lime_green = 0x32CD32,               // rgb(50,205,50)
-  linen = 0xFAF0E6,                    // rgb(250,240,230)
-  magenta = 0xFF00FF,                  // rgb(255,0,255)
-  maroon = 0x800000,                   // rgb(128,0,0)
-  medium_aquamarine = 0x66CDAA,        // rgb(102,205,170)
-  medium_blue = 0x0000CD,              // rgb(0,0,205)
-  medium_orchid = 0xBA55D3,            // rgb(186,85,211)
-  medium_purple = 0x9370DB,            // rgb(147,112,219)
-  medium_sea_green = 0x3CB371,         // rgb(60,179,113)
-  medium_slate_blue = 0x7B68EE,        // rgb(123,104,238)
-  medium_spring_green = 0x00FA9A,      // rgb(0,250,154)
-  medium_turquoise = 0x48D1CC,         // rgb(72,209,204)
-  medium_violet_red = 0xC71585,        // rgb(199,21,133)
-  midnight_blue = 0x191970,            // rgb(25,25,112)
-  mint_cream = 0xF5FFFA,               // rgb(245,255,250)
-  misty_rose = 0xFFE4E1,               // rgb(255,228,225)
-  moccasin = 0xFFE4B5,                 // rgb(255,228,181)
-  navajo_white = 0xFFDEAD,             // rgb(255,222,173)
-  navy = 0x000080,                     // rgb(0,0,128)
-  old_lace = 0xFDF5E6,                 // rgb(253,245,230)
-  olive = 0x808000,                    // rgb(128,128,0)
-  olive_drab = 0x6B8E23,               // rgb(107,142,35)
-  orange = 0xFFA500,                   // rgb(255,165,0)
-  orange_red = 0xFF4500,               // rgb(255,69,0)
-  orchid = 0xDA70D6,                   // rgb(218,112,214)
-  pale_golden_rod = 0xEEE8AA,          // rgb(238,232,170)
-  pale_green = 0x98FB98,               // rgb(152,251,152)
-  pale_turquoise = 0xAFEEEE,           // rgb(175,238,238)
-  pale_violet_red = 0xDB7093,          // rgb(219,112,147)
-  papaya_whip = 0xFFEFD5,              // rgb(255,239,213)
-  peach_puff = 0xFFDAB9,               // rgb(255,218,185)
-  peru = 0xCD853F,                     // rgb(205,133,63)
-  pink = 0xFFC0CB,                     // rgb(255,192,203)
-  plum = 0xDDA0DD,                     // rgb(221,160,221)
-  powder_blue = 0xB0E0E6,              // rgb(176,224,230)
-  purple = 0x800080,                   // rgb(128,0,128)
-  rebecca_purple = 0x663399,           // rgb(102,51,153)
-  red = 0xFF0000,                      // rgb(255,0,0)
-  rosy_brown = 0xBC8F8F,               // rgb(188,143,143)
-  royal_blue = 0x4169E1,               // rgb(65,105,225)
-  saddle_brown = 0x8B4513,             // rgb(139,69,19)
-  salmon = 0xFA8072,                   // rgb(250,128,114)
-  sandy_brown = 0xF4A460,              // rgb(244,164,96)
-  sea_green = 0x2E8B57,                // rgb(46,139,87)
-  sea_shell = 0xFFF5EE,                // rgb(255,245,238)
-  sienna = 0xA0522D,                   // rgb(160,82,45)
-  silver = 0xC0C0C0,                   // rgb(192,192,192)
-  sky_blue = 0x87CEEB,                 // rgb(135,206,235)
-  slate_blue = 0x6A5ACD,               // rgb(106,90,205)
-  slate_gray = 0x708090,               // rgb(112,128,144)
-  snow = 0xFFFAFA,                     // rgb(255,250,250)
-  spring_green = 0x00FF7F,             // rgb(0,255,127)
-  steel_blue = 0x4682B4,               // rgb(70,130,180)
-  tan = 0xD2B48C,                      // rgb(210,180,140)
-  teal = 0x008080,                     // rgb(0,128,128)
-  thistle = 0xD8BFD8,                  // rgb(216,191,216)
-  tomato = 0xFF6347,                   // rgb(255,99,71)
-  turquoise = 0x40E0D0,                // rgb(64,224,208)
-  violet = 0xEE82EE,                   // rgb(238,130,238)
-  wheat = 0xF5DEB3,                    // rgb(245,222,179)
-  white = 0xFFFFFF,                    // rgb(255,255,255)
-  white_smoke = 0xF5F5F5,              // rgb(245,245,245)
-  yellow = 0xFFFF00,                   // rgb(255,255,0)
-  yellow_green = 0x9ACD32              // rgb(154,205,50)
-};                                     // enum class color
-
-enum class terminal_color : uint8_t {
-  black = 30,
-  red,
-  green,
-  yellow,
-  blue,
-  magenta,
-  cyan,
-  white,
-  bright_black = 90,
-  bright_red,
-  bright_green,
-  bright_yellow,
-  bright_blue,
-  bright_magenta,
-  bright_cyan,
-  bright_white
-};
-
-enum class emphasis : uint8_t {
-  bold = 1,
-  faint = 1 << 1,
-  italic = 1 << 2,
-  underline = 1 << 3,
-  blink = 1 << 4,
-  reverse = 1 << 5,
-  conceal = 1 << 6,
-  strikethrough = 1 << 7,
-};
-
-// rgb is a struct for red, green and blue colors.
-// Using the name "rgb" makes some editors show the color in a tooltip.
-struct rgb {
-  constexpr rgb() : r(0), g(0), b(0) {}
-  constexpr rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {}
-  constexpr rgb(uint32_t hex)
-      : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {}
-  constexpr rgb(color hex)
-      : r((uint32_t(hex) >> 16) & 0xFF),
-        g((uint32_t(hex) >> 8) & 0xFF),
-        b(uint32_t(hex) & 0xFF) {}
-  uint8_t r;
-  uint8_t g;
-  uint8_t b;
-};
-
-namespace detail {
-
-// A bit-packed variant of an RGB color, a terminal color, or unset color.
-// see text_style for the bit-packing scheme.
-struct color_type {
-  constexpr color_type() noexcept = default;
-  constexpr color_type(color rgb_color) noexcept
-      : value_(static_cast<uint32_t>(rgb_color) | (1 << 24)) {}
-  constexpr color_type(rgb rgb_color) noexcept
-      : color_type(static_cast<color>(
-            (static_cast<uint32_t>(rgb_color.r) << 16) |
-            (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b)) {}
-  constexpr color_type(terminal_color term_color) noexcept
-      : value_(static_cast<uint32_t>(term_color) | (3 << 24)) {}
-
-  constexpr auto is_terminal_color() const noexcept -> bool {
-    return (value_ & (1 << 25)) != 0;
-  }
-
-  constexpr auto value() const noexcept -> uint32_t {
-    return value_ & 0xFFFFFF;
-  }
-
-  constexpr color_type(uint32_t value) noexcept : value_(value) {}
-
-  uint32_t value_ = 0;
-};
-}  // namespace detail
-
-/// A text style consisting of foreground and background colors and emphasis.
-class text_style {
-  // The information is packed as follows:
-  // ┌──┐
-  // │ 0│─┐
-  // │..│ ├── foreground color value
-  // │23│─┘
-  // ├──┤
-  // │24│─┬── discriminator for the above value. 00 if unset, 01 if it's
-  // │25│─┘   an RGB color, or 11 if it's a terminal color (10 is unused)
-  // ├──┤
-  // │26│──── overflow bit, always zero (see below)
-  // ├──┤
-  // │27│─┐
-  // │..│ │
-  // │50│ │
-  // ├──┤ │
-  // │51│ ├── background color (same format as the foreground color)
-  // │52│ │
-  // ├──┤ │
-  // │53│─┘
-  // ├──┤
-  // │54│─┐
-  // │..│ ├── emphases
-  // │61│─┘
-  // ├──┤
-  // │62│─┬── unused
-  // │63│─┘
-  // └──┘
-  // The overflow bits are there to make operator|= efficient.
-  // When ORing, we must throw if, for either the foreground or background,
-  // one style specifies a terminal color and the other specifies any color
-  // (terminal or RGB); in other words, if one discriminator is 11 and the
-  // other is 11 or 01.
-  //
-  // We do that check by adding the styles. Consider what adding does to each
-  // possible pair of discriminators:
-  //    00 + 00 = 000
-  //    01 + 00 = 001
-  //    11 + 00 = 011
-  //    01 + 01 = 010
-  //    11 + 01 = 100 (!!)
-  //    11 + 11 = 110 (!!)
-  // In the last two cases, the ones we want to catch, the third bit——the
-  // overflow bit——is set. Bingo.
-  //
-  // We must take into account the possible carry bit from the bits
-  // before the discriminator. The only potentially problematic case is
-  // 11 + 00 = 011 (a carry bit would make it 100, not good!), but a carry
-  // bit is impossible in that case, because 00 (unset color) means the
-  // 24 bits that precede the discriminator are all zero.
-  //
-  // This test can be applied to both colors simultaneously.
-
- public:
-  FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept
-      : style_(static_cast<uint64_t>(em) << 54) {}
-
-  FMT_CONSTEXPR auto operator|=(text_style rhs) -> text_style& {
-    if (((style_ + rhs.style_) & ((1ULL << 26) | (1ULL << 53))) != 0)
-      report_error("can't OR a terminal color");
-    style_ |= rhs.style_;
-    return *this;
-  }
-
-  friend FMT_CONSTEXPR auto operator|(text_style lhs, text_style rhs)
-      -> text_style {
-    return lhs |= rhs;
-  }
-
-  FMT_CONSTEXPR auto operator==(text_style rhs) const noexcept -> bool {
-    return style_ == rhs.style_;
-  }
-
-  FMT_CONSTEXPR auto operator!=(text_style rhs) const noexcept -> bool {
-    return !(*this == rhs);
-  }
-
-  FMT_CONSTEXPR auto has_foreground() const noexcept -> bool {
-    return (style_ & (1 << 24)) != 0;
-  }
-  FMT_CONSTEXPR auto has_background() const noexcept -> bool {
-    return (style_ & (1ULL << 51)) != 0;
-  }
-  FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool {
-    return (style_ >> 54) != 0;
-  }
-  FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type {
-    FMT_ASSERT(has_foreground(), "no foreground specified for this style");
-    return style_ & 0x3FFFFFF;
-  }
-  FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type {
-    FMT_ASSERT(has_background(), "no background specified for this style");
-    return (style_ >> 27) & 0x3FFFFFF;
-  }
-  FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis {
-    FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
-    return static_cast<emphasis>(style_ >> 54);
-  }
-
- private:
-  FMT_CONSTEXPR text_style(uint64_t style) noexcept : style_(style) {}
-
-  friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept
-      -> text_style;
-
-  friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept
-      -> text_style;
-
-  uint64_t style_ = 0;
-};
-
-/// Creates a text style from the foreground (text) color.
-FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept
-    -> text_style {
-  return foreground.value_;
-}
-
-/// Creates a text style from the background color.
-FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept
-    -> text_style {
-  return static_cast<uint64_t>(background.value_) << 27;
-}
-
-FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept
-    -> text_style {
-  return text_style(lhs) | rhs;
-}
-
-namespace detail {
-
-template <typename Char> struct ansi_color_escape {
-  FMT_CONSTEXPR ansi_color_escape(color_type text_color,
-                                  const char* esc) noexcept {
-    // If we have a terminal color, we need to output another escape code
-    // sequence.
-    if (text_color.is_terminal_color()) {
-      bool is_background = esc == string_view("\x1b[48;2;");
-      uint32_t value = text_color.value();
-      // Background ASCII codes are the same as the foreground ones but with
-      // 10 more.
-      if (is_background) value += 10u;
-
-      size_t index = 0;
-      buffer[index++] = static_cast<Char>('\x1b');
-      buffer[index++] = static_cast<Char>('[');
-
-      if (value >= 100u) {
-        buffer[index++] = static_cast<Char>('1');
-        value %= 100u;
-      }
-      buffer[index++] = static_cast<Char>('0' + value / 10u);
-      buffer[index++] = static_cast<Char>('0' + value % 10u);
-
-      buffer[index++] = static_cast<Char>('m');
-      buffer[index++] = static_cast<Char>('\0');
-      return;
-    }
-
-    for (int i = 0; i < 7; i++) {
-      buffer[i] = static_cast<Char>(esc[i]);
-    }
-    rgb color(text_color.value());
-    to_esc(color.r, buffer + 7, ';');
-    to_esc(color.g, buffer + 11, ';');
-    to_esc(color.b, buffer + 15, 'm');
-    buffer[19] = static_cast<Char>(0);
-  }
-  FMT_CONSTEXPR ansi_color_escape(emphasis em) noexcept {
-    uint8_t em_codes[num_emphases] = {};
-    if (has_emphasis(em, emphasis::bold)) em_codes[0] = 1;
-    if (has_emphasis(em, emphasis::faint)) em_codes[1] = 2;
-    if (has_emphasis(em, emphasis::italic)) em_codes[2] = 3;
-    if (has_emphasis(em, emphasis::underline)) em_codes[3] = 4;
-    if (has_emphasis(em, emphasis::blink)) em_codes[4] = 5;
-    if (has_emphasis(em, emphasis::reverse)) em_codes[5] = 7;
-    if (has_emphasis(em, emphasis::conceal)) em_codes[6] = 8;
-    if (has_emphasis(em, emphasis::strikethrough)) em_codes[7] = 9;
-
-    size_t index = 0;
-    for (size_t i = 0; i < num_emphases; ++i) {
-      if (!em_codes[i]) continue;
-      buffer[index++] = static_cast<Char>('\x1b');
-      buffer[index++] = static_cast<Char>('[');
-      buffer[index++] = static_cast<Char>('0' + em_codes[i]);
-      buffer[index++] = static_cast<Char>('m');
-    }
-    buffer[index++] = static_cast<Char>(0);
-  }
-  FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; }
-
-  FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; }
-  FMT_CONSTEXPR20 auto end() const noexcept -> const Char* {
-    return buffer + basic_string_view<Char>(buffer).size();
-  }
-
- private:
-  static constexpr size_t num_emphases = 8;
-  Char buffer[7u + 3u * num_emphases + 1u];
-
-  static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out,
-                                   char delimiter) noexcept {
-    out[0] = static_cast<Char>('0' + c / 100);
-    out[1] = static_cast<Char>('0' + c / 10 % 10);
-    out[2] = static_cast<Char>('0' + c % 10);
-    out[3] = static_cast<Char>(delimiter);
-  }
-  static FMT_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept
-      -> bool {
-    return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask);
-  }
-};
-
-template <typename Char>
-FMT_CONSTEXPR auto make_foreground_color(color_type foreground) noexcept
-    -> ansi_color_escape<Char> {
-  return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
-}
-
-template <typename Char>
-FMT_CONSTEXPR auto make_background_color(color_type background) noexcept
-    -> ansi_color_escape<Char> {
-  return ansi_color_escape<Char>(background, "\x1b[48;2;");
-}
-
-template <typename Char>
-FMT_CONSTEXPR auto make_emphasis(emphasis em) noexcept
-    -> ansi_color_escape<Char> {
-  return ansi_color_escape<Char>(em);
-}
-
-template <typename Char> inline void reset_color(buffer<Char>& buffer) {
-  auto reset_color = string_view("\x1b[0m");
-  buffer.append(reset_color.begin(), reset_color.end());
-}
-
-template <typename T> struct styled_arg : view {
-  const T& value;
-  text_style style;
-  styled_arg(const T& v, text_style s) : value(v), style(s) {}
-};
-
-template <typename Char>
-void vformat_to(buffer<Char>& buf, text_style ts, basic_string_view<Char> fmt,
-                basic_format_args<buffered_context<Char>> args) {
-  if (ts.has_emphasis()) {
-    auto emphasis = make_emphasis<Char>(ts.get_emphasis());
-    buf.append(emphasis.begin(), emphasis.end());
-  }
-  if (ts.has_foreground()) {
-    auto foreground = make_foreground_color<Char>(ts.get_foreground());
-    buf.append(foreground.begin(), foreground.end());
-  }
-  if (ts.has_background()) {
-    auto background = make_background_color<Char>(ts.get_background());
-    buf.append(background.begin(), background.end());
-  }
-  vformat_to(buf, fmt, args);
-  if (ts != text_style()) reset_color<Char>(buf);
-}
-}  // namespace detail
-
-inline void vprint(FILE* f, text_style ts, string_view fmt, format_args args) {
-  auto buf = memory_buffer();
-  detail::vformat_to(buf, ts, fmt, args);
-  print(f, FMT_STRING("{}"), string_view(buf.begin(), buf.size()));
-}
-
-/**
- * Formats a string and prints it to the specified file stream using ANSI
- * escape sequences to specify text formatting.
- *
- * **Example**:
- *
- *     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
- *                "Elapsed time: {0:.2f} seconds", 1.23);
- */
-template <typename... T>
-void print(FILE* f, text_style ts, format_string<T...> fmt, T&&... args) {
-  vprint(f, ts, fmt.str, vargs<T...>{{args...}});
-}
-
-/**
- * Formats a string and prints it to stdout using ANSI escape sequences to
- * specify text formatting.
- *
- * **Example**:
- *
- *     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
- *                "Elapsed time: {0:.2f} seconds", 1.23);
- */
-template <typename... T>
-void print(text_style ts, format_string<T...> fmt, T&&... args) {
-  return print(stdout, ts, fmt, std::forward<T>(args)...);
-}
-
-inline auto vformat(text_style ts, string_view fmt, format_args args)
-    -> std::string {
-  auto buf = memory_buffer();
-  detail::vformat_to(buf, ts, fmt, args);
-  return fmt::to_string(buf);
-}
-
-/**
- * Formats arguments and returns the result as a string using ANSI escape
- * sequences to specify text formatting.
- *
- * **Example**:
- *
- * ```
- * #include <fmt/color.h>
- * std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
- *                                   "The answer is {}", 42);
- * ```
- */
-template <typename... T>
-inline auto format(text_style ts, format_string<T...> fmt, T&&... args)
-    -> std::string {
-  return fmt::vformat(ts, fmt.str, vargs<T...>{{args...}});
-}
-
-/// Formats a string with the given text_style and writes the output to `out`.
-template <typename OutputIt,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-auto vformat_to(OutputIt out, text_style ts, string_view fmt, format_args args)
-    -> OutputIt {
-  auto&& buf = detail::get_buffer<char>(out);
-  detail::vformat_to(buf, ts, fmt, args);
-  return detail::get_iterator(buf, out);
-}
-
-/**
- * Formats arguments with the given text style, writes the result to the output
- * iterator `out` and returns the iterator past the end of the output range.
- *
- * **Example**:
- *
- *     std::vector<char> out;
- *     fmt::format_to(std::back_inserter(out),
- *                    fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
- */
-template <typename OutputIt, typename... T,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-inline auto format_to(OutputIt out, text_style ts, format_string<T...> fmt,
-                      T&&... args) -> OutputIt {
-  return vformat_to(out, ts, fmt.str, vargs<T...>{{args...}});
-}
-
-template <typename T, typename Char>
-struct formatter<detail::styled_arg<T>, Char> : formatter<T, Char> {
-  template <typename FormatContext>
-  auto format(const detail::styled_arg<T>& arg, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    const auto& ts = arg.style;
-    auto out = ctx.out();
-
-    bool has_style = false;
-    if (ts.has_emphasis()) {
-      has_style = true;
-      auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
-      out = detail::copy<Char>(emphasis.begin(), emphasis.end(), out);
-    }
-    if (ts.has_foreground()) {
-      has_style = true;
-      auto foreground =
-          detail::make_foreground_color<Char>(ts.get_foreground());
-      out = detail::copy<Char>(foreground.begin(), foreground.end(), out);
-    }
-    if (ts.has_background()) {
-      has_style = true;
-      auto background =
-          detail::make_background_color<Char>(ts.get_background());
-      out = detail::copy<Char>(background.begin(), background.end(), out);
-    }
-    out = formatter<T, Char>::format(arg.value, ctx);
-    if (has_style) {
-      auto reset_color = string_view("\x1b[0m");
-      out = detail::copy<Char>(reset_color.begin(), reset_color.end(), out);
-    }
-    return out;
-  }
-};
-
-/**
- * Returns an argument that will be formatted using ANSI escape sequences,
- * to be used in a formatting function.
- *
- * **Example**:
- *
- *     fmt::print("Elapsed time: {0:.2f} seconds",
- *                fmt::styled(1.23, fmt::fg(fmt::color::green) |
- *                                  fmt::bg(fmt::color::blue)));
- */
-template <typename T>
-FMT_CONSTEXPR auto styled(const T& value, text_style ts)
-    -> detail::styled_arg<remove_cvref_t<T>> {
-  return detail::styled_arg<remove_cvref_t<T>>{value, ts};
-}
-
-FMT_END_EXPORT
-FMT_END_NAMESPACE
-
-#endif  // FMT_COLOR_H_
@@ -1,539 +0,0 @@
-// Formatting library for C++ - experimental format string compilation
-//
-// Copyright (c) 2012 - present, Victor Zverovich and fmt contributors
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_COMPILE_H_
-#define FMT_COMPILE_H_
-
-#ifndef FMT_MODULE
-#  include <iterator>  // std::back_inserter
-#endif
-
-#include "format.h"
-
-FMT_BEGIN_NAMESPACE
-
-// A compile-time string which is compiled into fast formatting code.
-FMT_EXPORT class compiled_string {};
-
-template <typename S>
-struct is_compiled_string : std::is_base_of<compiled_string, S> {};
-
-namespace detail {
-
-/**
- * Converts a string literal `s` into a format string that will be parsed at
- * compile time and converted into efficient formatting code. Requires C++17
- * `constexpr if` compiler support.
- *
- * **Example**:
- *
- *     // Converts 42 into std::string using the most efficient method and no
- *     // runtime format string processing.
- *     std::string s = fmt::format(FMT_COMPILE("{}"), 42);
- */
-#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
-#  define FMT_COMPILE(s) FMT_STRING_IMPL(s, fmt::compiled_string)
-#else
-#  define FMT_COMPILE(s) FMT_STRING(s)
-#endif
-
-template <typename T, typename... Tail>
-auto first(const T& value, const Tail&...) -> const T& {
-  return value;
-}
-
-#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
-template <typename... Args> struct type_list {};
-
-// Returns a reference to the argument at index N from [first, rest...].
-template <int N, typename T, typename... Args>
-constexpr const auto& get([[maybe_unused]] const T& first,
-                          [[maybe_unused]] const Args&... rest) {
-  static_assert(N < 1 + sizeof...(Args), "index is out of bounds");
-  if constexpr (N == 0)
-    return first;
-  else
-    return detail::get<N - 1>(rest...);
-}
-
-#  if FMT_USE_NONTYPE_TEMPLATE_ARGS
-template <int N, typename T, typename... Args, typename Char>
-constexpr auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
-  if constexpr (is_static_named_arg<T>()) {
-    if (name == T::name) return N;
-  }
-  if constexpr (sizeof...(Args) > 0)
-    return get_arg_index_by_name<N + 1, Args...>(name);
-  (void)name;  // Workaround an MSVC bug about "unused" parameter.
-  return -1;
-}
-#  endif
-
-template <typename... Args, typename Char>
-FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
-#  if FMT_USE_NONTYPE_TEMPLATE_ARGS
-  if constexpr (sizeof...(Args) > 0)
-    return get_arg_index_by_name<0, Args...>(name);
-#  endif
-  (void)name;
-  return -1;
-}
-
-template <typename Char, typename... Args>
-constexpr int get_arg_index_by_name(basic_string_view<Char> name,
-                                    type_list<Args...>) {
-  return get_arg_index_by_name<Args...>(name);
-}
-
-template <int N, typename> struct get_type_impl;
-
-template <int N, typename... Args> struct get_type_impl<N, type_list<Args...>> {
-  using type =
-      remove_cvref_t<decltype(detail::get<N>(std::declval<Args>()...))>;
-};
-
-template <int N, typename T>
-using get_type = typename get_type_impl<N, T>::type;
-
-template <typename T> struct is_compiled_format : std::false_type {};
-
-template <typename Char> struct text {
-  basic_string_view<Char> data;
-  using char_type = Char;
-
-  template <typename OutputIt, typename... Args>
-  constexpr OutputIt format(OutputIt out, const Args&...) const {
-    return write<Char>(out, data);
-  }
-};
-
-template <typename Char>
-struct is_compiled_format<text<Char>> : std::true_type {};
-
-template <typename Char>
-constexpr text<Char> make_text(basic_string_view<Char> s, size_t pos,
-                               size_t size) {
-  return {{&s[pos], size}};
-}
-
-template <typename Char> struct code_unit {
-  Char value;
-  using char_type = Char;
-
-  template <typename OutputIt, typename... Args>
-  constexpr OutputIt format(OutputIt out, const Args&...) const {
-    *out++ = value;
-    return out;
-  }
-};
-
-// This ensures that the argument type is convertible to `const T&`.
-template <typename T, int N, typename... Args>
-constexpr const T& get_arg_checked(const Args&... args) {
-  const auto& arg = detail::get<N>(args...);
-  if constexpr (detail::is_named_arg<remove_cvref_t<decltype(arg)>>()) {
-    return arg.value;
-  } else {
-    return arg;
-  }
-}
-
-template <typename Char>
-struct is_compiled_format<code_unit<Char>> : std::true_type {};
-
-// A replacement field that refers to argument N.
-template <typename Char, typename T, int N> struct field {
-  using char_type = Char;
-
-  template <typename OutputIt, typename... Args>
-  constexpr OutputIt format(OutputIt out, const Args&... args) const {
-    const T& arg = get_arg_checked<T, N>(args...);
-    if constexpr (std::is_convertible<T, basic_string_view<Char>>::value) {
-      auto s = basic_string_view<Char>(arg);
-      return copy<Char>(s.begin(), s.end(), out);
-    } else {
-      return write<Char>(out, arg);
-    }
-  }
-};
-
-template <typename Char, typename T, int N>
-struct is_compiled_format<field<Char, T, N>> : std::true_type {};
-
-// A replacement field that refers to argument with name.
-template <typename Char> struct runtime_named_field {
-  using char_type = Char;
-  basic_string_view<Char> name;
-
-  template <typename OutputIt, typename T>
-  constexpr static bool try_format_argument(
-      OutputIt& out,
-      // [[maybe_unused]] due to unused-but-set-parameter warning in GCC 7,8,9
-      [[maybe_unused]] basic_string_view<Char> arg_name, const T& arg) {
-    if constexpr (is_named_arg<typename std::remove_cv<T>::type>::value) {
-      if (arg_name == arg.name) {
-        out = write<Char>(out, arg.value);
-        return true;
-      }
-    }
-    return false;
-  }
-
-  template <typename OutputIt, typename... Args>
-  constexpr OutputIt format(OutputIt out, const Args&... args) const {
-    bool found = (try_format_argument(out, name, args) || ...);
-    if (!found) {
-      FMT_THROW(format_error("argument with specified name is not found"));
-    }
-    return out;
-  }
-};
-
-template <typename Char>
-struct is_compiled_format<runtime_named_field<Char>> : std::true_type {};
-
-// A replacement field that refers to argument N and has format specifiers.
-template <typename Char, typename T, int N> struct spec_field {
-  using char_type = Char;
-  formatter<T, Char> fmt;
-
-  template <typename OutputIt, typename... Args>
-  constexpr FMT_INLINE OutputIt format(OutputIt out,
-                                       const Args&... args) const {
-    const auto& vargs =
-        fmt::make_format_args<basic_format_context<OutputIt, Char>>(args...);
-    basic_format_context<OutputIt, Char> ctx(out, vargs);
-    return fmt.format(get_arg_checked<T, N>(args...), ctx);
-  }
-};
-
-template <typename Char, typename T, int N>
-struct is_compiled_format<spec_field<Char, T, N>> : std::true_type {};
-
-template <typename L, typename R> struct concat {
-  L lhs;
-  R rhs;
-  using char_type = typename L::char_type;
-
-  template <typename OutputIt, typename... Args>
-  constexpr OutputIt format(OutputIt out, const Args&... args) const {
-    out = lhs.format(out, args...);
-    return rhs.format(out, args...);
-  }
-};
-
-template <typename L, typename R>
-struct is_compiled_format<concat<L, R>> : std::true_type {};
-
-template <typename L, typename R>
-constexpr concat<L, R> make_concat(L lhs, R rhs) {
-  return {lhs, rhs};
-}
-
-struct unknown_format {};
-
-template <typename Char>
-constexpr size_t parse_text(basic_string_view<Char> str, size_t pos) {
-  for (size_t size = str.size(); pos != size; ++pos) {
-    if (str[pos] == '{' || str[pos] == '}') break;
-  }
-  return pos;
-}
-
-template <typename Args, size_t POS, int ID, typename S>
-constexpr auto compile_format_string(S fmt);
-
-template <typename Args, size_t POS, int ID, typename T, typename S>
-constexpr auto parse_tail(T head, S fmt) {
-  if constexpr (POS != basic_string_view<typename S::char_type>(fmt).size()) {
-    constexpr auto tail = compile_format_string<Args, POS, ID>(fmt);
-    if constexpr (std::is_same<remove_cvref_t<decltype(tail)>,
-                               unknown_format>())
-      return tail;
-    else
-      return make_concat(head, tail);
-  } else {
-    return head;
-  }
-}
-
-template <typename T, typename Char> struct parse_specs_result {
-  formatter<T, Char> fmt;
-  size_t end;
-  int next_arg_id;
-};
-
-enum { manual_indexing_id = -1 };
-
-template <typename T, typename Char>
-constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
-                                                  size_t pos, int next_arg_id) {
-  str.remove_prefix(pos);
-  auto ctx =
-      compile_parse_context<Char>(str, max_value<int>(), nullptr, next_arg_id);
-  auto f = formatter<T, Char>();
-  auto end = f.parse(ctx);
-  return {f, pos + fmt::detail::to_unsigned(end - str.data()),
-          next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()};
-}
-
-template <typename Char> struct arg_id_handler {
-  arg_id_kind kind;
-  arg_ref<Char> arg_id;
-
-  constexpr int on_auto() {
-    FMT_ASSERT(false, "handler cannot be used with automatic indexing");
-    return 0;
-  }
-  constexpr int on_index(int id) {
-    kind = arg_id_kind::index;
-    arg_id = arg_ref<Char>(id);
-    return 0;
-  }
-  constexpr int on_name(basic_string_view<Char> id) {
-    kind = arg_id_kind::name;
-    arg_id = arg_ref<Char>(id);
-    return 0;
-  }
-};
-
-template <typename Char> struct parse_arg_id_result {
-  arg_id_kind kind;
-  arg_ref<Char> arg_id;
-  const Char* arg_id_end;
-};
-
-template <int ID, typename Char>
-constexpr auto parse_arg_id(const Char* begin, const Char* end) {
-  auto handler = arg_id_handler<Char>{arg_id_kind::none, arg_ref<Char>{}};
-  auto arg_id_end = parse_arg_id(begin, end, handler);
-  return parse_arg_id_result<Char>{handler.kind, handler.arg_id, arg_id_end};
-}
-
-template <typename T, typename Enable = void> struct field_type {
-  using type = remove_cvref_t<T>;
-};
-
-template <typename T>
-struct field_type<T, enable_if_t<detail::is_named_arg<T>::value>> {
-  using type = remove_cvref_t<decltype(T::value)>;
-};
-
-template <typename T, typename Args, size_t END_POS, int ARG_INDEX, int NEXT_ID,
-          typename S>
-constexpr auto parse_replacement_field_then_tail(S fmt) {
-  using char_type = typename S::char_type;
-  constexpr auto str = basic_string_view<char_type>(fmt);
-  constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type();
-  if constexpr (c == '}') {
-    return parse_tail<Args, END_POS + 1, NEXT_ID>(
-        field<char_type, typename field_type<T>::type, ARG_INDEX>(), fmt);
-  } else if constexpr (c != ':') {
-    FMT_THROW(format_error("expected ':'"));
-  } else {
-    constexpr auto result = parse_specs<typename field_type<T>::type>(
-        str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID);
-    if constexpr (result.end >= str.size() || str[result.end] != '}') {
-      FMT_THROW(format_error("expected '}'"));
-      return 0;
-    } else {
-      return parse_tail<Args, result.end + 1, result.next_arg_id>(
-          spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
-              result.fmt},
-          fmt);
-    }
-  }
-}
-
-// Compiles a non-empty format string and returns the compiled representation
-// or unknown_format() on unrecognized input.
-template <typename Args, size_t POS, int ID, typename S>
-constexpr auto compile_format_string(S fmt) {
-  using char_type = typename S::char_type;
-  constexpr auto str = basic_string_view<char_type>(fmt);
-  if constexpr (str[POS] == '{') {
-    if constexpr (POS + 1 == str.size())
-      FMT_THROW(format_error("unmatched '{' in format string"));
-    if constexpr (str[POS + 1] == '{') {
-      return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt);
-    } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') {
-      static_assert(ID != manual_indexing_id,
-                    "cannot switch from manual to automatic argument indexing");
-      constexpr auto next_id =
-          ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
-      return parse_replacement_field_then_tail<get_type<ID, Args>, Args,
-                                               POS + 1, ID, next_id>(fmt);
-    } else {
-      constexpr auto arg_id_result =
-          parse_arg_id<ID>(str.data() + POS + 1, str.data() + str.size());
-      constexpr auto arg_id_end_pos = arg_id_result.arg_id_end - str.data();
-      constexpr char_type c =
-          arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type();
-      static_assert(c == '}' || c == ':', "missing '}' in format string");
-      if constexpr (arg_id_result.kind == arg_id_kind::index) {
-        static_assert(
-            ID == manual_indexing_id || ID == 0,
-            "cannot switch from automatic to manual argument indexing");
-        constexpr auto arg_index = arg_id_result.arg_id.index;
-        return parse_replacement_field_then_tail<get_type<arg_index, Args>,
-                                                 Args, arg_id_end_pos,
-                                                 arg_index, manual_indexing_id>(
-            fmt);
-      } else if constexpr (arg_id_result.kind == arg_id_kind::name) {
-        constexpr auto arg_index =
-            get_arg_index_by_name(arg_id_result.arg_id.name, Args{});
-        if constexpr (arg_index >= 0) {
-          constexpr auto next_id =
-              ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
-          return parse_replacement_field_then_tail<
-              decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos,
-              arg_index, next_id>(fmt);
-        } else if constexpr (c == '}') {
-          return parse_tail<Args, arg_id_end_pos + 1, ID>(
-              runtime_named_field<char_type>{arg_id_result.arg_id.name}, fmt);
-        } else if constexpr (c == ':') {
-          return unknown_format();  // no type info for specs parsing
-        }
-      }
-    }
-  } else if constexpr (str[POS] == '}') {
-    if constexpr (POS + 1 == str.size())
-      FMT_THROW(format_error("unmatched '}' in format string"));
-    return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt);
-  } else {
-    constexpr auto end = parse_text(str, POS + 1);
-    if constexpr (end - POS > 1) {
-      return parse_tail<Args, end, ID>(make_text(str, POS, end - POS), fmt);
-    } else {
-      return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]}, fmt);
-    }
-  }
-}
-
-template <typename... Args, typename S,
-          FMT_ENABLE_IF(is_compiled_string<S>::value)>
-constexpr auto compile(S fmt) {
-  constexpr auto str = basic_string_view<typename S::char_type>(fmt);
-  if constexpr (str.size() == 0) {
-    return detail::make_text(str, 0, 0);
-  } else {
-    constexpr auto result =
-        detail::compile_format_string<detail::type_list<Args...>, 0, 0>(fmt);
-    return result;
-  }
-}
-#endif  // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
-}  // namespace detail
-
-FMT_BEGIN_EXPORT
-
-#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
-
-template <typename CompiledFormat, typename... Args,
-          typename Char = typename CompiledFormat::char_type,
-          FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
-FMT_INLINE std::basic_string<Char> format(const CompiledFormat& cf,
-                                          const Args&... args) {
-  auto s = std::basic_string<Char>();
-  cf.format(std::back_inserter(s), args...);
-  return s;
-}
-
-template <typename OutputIt, typename CompiledFormat, typename... Args,
-          FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
-constexpr FMT_INLINE OutputIt format_to(OutputIt out, const CompiledFormat& cf,
-                                        const Args&... args) {
-  return cf.format(out, args...);
-}
-
-template <typename S, typename... Args,
-          FMT_ENABLE_IF(is_compiled_string<S>::value)>
-FMT_INLINE std::basic_string<typename S::char_type> format(const S&,
-                                                           Args&&... args) {
-  if constexpr (std::is_same<typename S::char_type, char>::value) {
-    constexpr auto str = basic_string_view<typename S::char_type>(S());
-    if constexpr (str.size() == 2 && str[0] == '{' && str[1] == '}') {
-      const auto& first = detail::first(args...);
-      if constexpr (detail::is_named_arg<
-                        remove_cvref_t<decltype(first)>>::value) {
-        return fmt::to_string(first.value);
-      } else {
-        return fmt::to_string(first);
-      }
-    }
-  }
-  constexpr auto compiled = detail::compile<Args...>(S());
-  if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
-                             detail::unknown_format>()) {
-    return fmt::format(
-        static_cast<basic_string_view<typename S::char_type>>(S()),
-        std::forward<Args>(args)...);
-  } else {
-    return fmt::format(compiled, std::forward<Args>(args)...);
-  }
-}
-
-template <typename OutputIt, typename S, typename... Args,
-          FMT_ENABLE_IF(is_compiled_string<S>::value)>
-FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
-  constexpr auto compiled = detail::compile<Args...>(S());
-  if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
-                             detail::unknown_format>()) {
-    return fmt::format_to(
-        out, static_cast<basic_string_view<typename S::char_type>>(S()),
-        std::forward<Args>(args)...);
-  } else {
-    return fmt::format_to(out, compiled, std::forward<Args>(args)...);
-  }
-}
-#endif
-
-template <typename OutputIt, typename S, typename... Args,
-          FMT_ENABLE_IF(is_compiled_string<S>::value)>
-auto format_to_n(OutputIt out, size_t n, const S& fmt, Args&&... args)
-    -> format_to_n_result<OutputIt> {
-  using traits = detail::fixed_buffer_traits;
-  auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
-  fmt::format_to(std::back_inserter(buf), fmt, std::forward<Args>(args)...);
-  return {buf.out(), buf.count()};
-}
-
-template <typename S, typename... Args,
-          FMT_ENABLE_IF(is_compiled_string<S>::value)>
-FMT_CONSTEXPR20 auto formatted_size(const S& fmt, const Args&... args)
-    -> size_t {
-  auto buf = detail::counting_buffer<>();
-  fmt::format_to(appender(buf), fmt, args...);
-  return buf.count();
-}
-
-template <typename S, typename... Args,
-          FMT_ENABLE_IF(is_compiled_string<S>::value)>
-void print(std::FILE* f, const S& fmt, const Args&... args) {
-  auto buf = memory_buffer();
-  fmt::format_to(appender(buf), fmt, args...);
-  detail::print(f, {buf.data(), buf.size()});
-}
-
-template <typename S, typename... Args,
-          FMT_ENABLE_IF(is_compiled_string<S>::value)>
-void print(const S& fmt, const Args&... args) {
-  print(stdout, fmt, args...);
-}
-
-#if FMT_USE_NONTYPE_TEMPLATE_ARGS
-inline namespace literals {
-template <detail::fixed_string Str> constexpr auto operator""_cf() {
-  return FMT_COMPILE(Str.data);
-}
-}  // namespace literals
-#endif
-
-FMT_END_EXPORT
-FMT_END_NAMESPACE
-
-#endif  // FMT_COMPILE_H_
@@ -1,5 +0,0 @@
-// This file is only provided for compatibility and may be removed in future
-// versions. Use fmt/base.h if you don't need fmt::format and fmt/format.h
-// otherwise.
-
-#include "format.h"
@@ -1,427 +0,0 @@
-// Formatting library for C++ - optional OS-specific functionality
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_OS_H_
-#define FMT_OS_H_
-
-#include "format.h"
-
-#ifndef FMT_MODULE
-#  include <cerrno>
-#  include <cstddef>
-#  include <cstdio>
-#  include <system_error>  // std::system_error
-
-#  if FMT_HAS_INCLUDE(<xlocale.h>)
-#    include <xlocale.h>  // LC_NUMERIC_MASK on macOS
-#  endif
-#endif  // FMT_MODULE
-
-#ifndef FMT_USE_FCNTL
-// UWP doesn't provide _pipe.
-#  if FMT_HAS_INCLUDE("winapifamily.h")
-#    include <winapifamily.h>
-#  endif
-#  if (FMT_HAS_INCLUDE(<fcntl.h>) || defined(__APPLE__) || \
-       defined(__linux__)) &&                              \
-      (!defined(WINAPI_FAMILY) ||                          \
-       (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
-#    include <fcntl.h>  // for O_RDONLY
-#    define FMT_USE_FCNTL 1
-#  else
-#    define FMT_USE_FCNTL 0
-#  endif
-#endif
-
-#ifndef FMT_POSIX
-#  if defined(_WIN32) && !defined(__MINGW32__)
-// Fix warnings about deprecated symbols.
-#    define FMT_POSIX(call) _##call
-#  else
-#    define FMT_POSIX(call) call
-#  endif
-#endif
-
-// Calls to system functions are wrapped in FMT_SYSTEM for testability.
-#ifdef FMT_SYSTEM
-#  define FMT_HAS_SYSTEM
-#  define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
-#else
-#  define FMT_SYSTEM(call) ::call
-#  ifdef _WIN32
-// Fix warnings about deprecated symbols.
-#    define FMT_POSIX_CALL(call) ::_##call
-#  else
-#    define FMT_POSIX_CALL(call) ::call
-#  endif
-#endif
-
-// Retries the expression while it evaluates to error_result and errno
-// equals to EINTR.
-#ifndef _WIN32
-#  define FMT_RETRY_VAL(result, expression, error_result) \
-    do {                                                  \
-      (result) = (expression);                            \
-    } while ((result) == (error_result) && errno == EINTR)
-#else
-#  define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
-#endif
-
-#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
-
-FMT_BEGIN_NAMESPACE
-FMT_BEGIN_EXPORT
-
-/**
- * A reference to a null-terminated string. It can be constructed from a C
- * string or `std::string`.
- *
- * You can use one of the following type aliases for common character types:
- *
- * +---------------+-----------------------------+
- * | Type          | Definition                  |
- * +===============+=============================+
- * | cstring_view  | basic_cstring_view<char>    |
- * +---------------+-----------------------------+
- * | wcstring_view | basic_cstring_view<wchar_t> |
- * +---------------+-----------------------------+
- *
- * This class is most useful as a parameter type for functions that wrap C APIs.
- */
-template <typename Char> class basic_cstring_view {
- private:
-  const Char* data_;
-
- public:
-  /// Constructs a string reference object from a C string.
-  basic_cstring_view(const Char* s) : data_(s) {}
-
-  /// Constructs a string reference from an `std::string` object.
-  basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {}
-
-  /// Returns the pointer to a C string.
-  auto c_str() const -> const Char* { return data_; }
-};
-
-using cstring_view = basic_cstring_view<char>;
-using wcstring_view = basic_cstring_view<wchar_t>;
-
-#ifdef _WIN32
-FMT_API const std::error_category& system_category() noexcept;
-
-namespace detail {
-FMT_API void format_windows_error(buffer<char>& out, int error_code,
-                                  const char* message) noexcept;
-}
-
-FMT_API std::system_error vwindows_error(int error_code, string_view fmt,
-                                         format_args args);
-
-/**
- * Constructs a `std::system_error` object with the description of the form
- *
- *     <message>: <system-message>
- *
- * where `<message>` is the formatted message and `<system-message>` is the
- * system message corresponding to the error code.
- * `error_code` is a Windows error code as given by `GetLastError`.
- * If `error_code` is not a valid error code such as -1, the system message
- * will look like "error -1".
- *
- * **Example**:
- *
- *     // This throws a system_error with the description
- *     //   cannot open file 'madeup': The system cannot find the file
- * specified.
- *     // or similar (system message may vary).
- *     const char *filename = "madeup";
- *     LPOFSTRUCT of = LPOFSTRUCT();
- *     HFILE file = OpenFile(filename, &of, OF_READ);
- *     if (file == HFILE_ERROR) {
- *       throw fmt::windows_error(GetLastError(),
- *                                "cannot open file '{}'", filename);
- *     }
- */
-template <typename... T>
-auto windows_error(int error_code, string_view message, const T&... args)
-    -> std::system_error {
-  return vwindows_error(error_code, message, vargs<T...>{{args...}});
-}
-
-// Reports a Windows error without throwing an exception.
-// Can be used to report errors from destructors.
-FMT_API void report_windows_error(int error_code, const char* message) noexcept;
-#else
-inline auto system_category() noexcept -> const std::error_category& {
-  return std::system_category();
-}
-#endif  // _WIN32
-
-// std::system is not available on some platforms such as iOS (#2248).
-#ifdef __OSX__
-template <typename S, typename... Args, typename Char = char_t<S>>
-void say(const S& fmt, Args&&... args) {
-  std::system(format("say \"{}\"", format(fmt, args...)).c_str());
-}
-#endif
-
-// A buffered file.
-class buffered_file {
- private:
-  FILE* file_;
-
-  friend class file;
-
-  inline explicit buffered_file(FILE* f) : file_(f) {}
-
- public:
-  buffered_file(const buffered_file&) = delete;
-  void operator=(const buffered_file&) = delete;
-
-  // Constructs a buffered_file object which doesn't represent any file.
-  inline buffered_file() noexcept : file_(nullptr) {}
-
-  // Destroys the object closing the file it represents if any.
-  FMT_API ~buffered_file() noexcept;
-
- public:
-  inline buffered_file(buffered_file&& other) noexcept : file_(other.file_) {
-    other.file_ = nullptr;
-  }
-
-  inline auto operator=(buffered_file&& other) -> buffered_file& {
-    close();
-    file_ = other.file_;
-    other.file_ = nullptr;
-    return *this;
-  }
-
-  // Opens a file.
-  FMT_API buffered_file(cstring_view filename, cstring_view mode);
-
-  // Closes the file.
-  FMT_API void close();
-
-  // Returns the pointer to a FILE object representing this file.
-  inline auto get() const noexcept -> FILE* { return file_; }
-
-  FMT_API auto descriptor() const -> int;
-
-  template <typename... T>
-  inline void print(string_view fmt, const T&... args) {
-    fmt::vargs<T...> vargs = {{args...}};
-    detail::is_locking<T...>() ? fmt::vprint_buffered(file_, fmt, vargs)
-                               : fmt::vprint(file_, fmt, vargs);
-  }
-};
-
-#if FMT_USE_FCNTL
-
-// A file. Closed file is represented by a file object with descriptor -1.
-// Methods that are not declared with noexcept may throw
-// fmt::system_error in case of failure. Note that some errors such as
-// closing the file multiple times will cause a crash on Windows rather
-// than an exception. You can get standard behavior by overriding the
-// invalid parameter handler with _set_invalid_parameter_handler.
-class FMT_API file {
- private:
-  int fd_;  // File descriptor.
-
-  // Constructs a file object with a given descriptor.
-  explicit file(int fd) : fd_(fd) {}
-
-  friend struct pipe;
-
- public:
-  // Possible values for the oflag argument to the constructor.
-  enum {
-    RDONLY = FMT_POSIX(O_RDONLY),  // Open for reading only.
-    WRONLY = FMT_POSIX(O_WRONLY),  // Open for writing only.
-    RDWR = FMT_POSIX(O_RDWR),      // Open for reading and writing.
-    CREATE = FMT_POSIX(O_CREAT),   // Create if the file doesn't exist.
-    APPEND = FMT_POSIX(O_APPEND),  // Open in append mode.
-    TRUNC = FMT_POSIX(O_TRUNC)     // Truncate the content of the file.
-  };
-
-  // Constructs a file object which doesn't represent any file.
-  inline file() noexcept : fd_(-1) {}
-
-  // Opens a file and constructs a file object representing this file.
-  file(cstring_view path, int oflag);
-
- public:
-  file(const file&) = delete;
-  void operator=(const file&) = delete;
-
-  inline file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }
-
-  // Move assignment is not noexcept because close may throw.
-  inline auto operator=(file&& other) -> file& {
-    close();
-    fd_ = other.fd_;
-    other.fd_ = -1;
-    return *this;
-  }
-
-  // Destroys the object closing the file it represents if any.
-  ~file() noexcept;
-
-  // Returns the file descriptor.
-  inline auto descriptor() const noexcept -> int { return fd_; }
-
-  // Closes the file.
-  void close();
-
-  // Returns the file size. The size has signed type for consistency with
-  // stat::st_size.
-  auto size() const -> long long;
-
-  // Attempts to read count bytes from the file into the specified buffer.
-  auto read(void* buffer, size_t count) -> size_t;
-
-  // Attempts to write count bytes from the specified buffer to the file.
-  auto write(const void* buffer, size_t count) -> size_t;
-
-  // Duplicates a file descriptor with the dup function and returns
-  // the duplicate as a file object.
-  static auto dup(int fd) -> file;
-
-  // Makes fd be the copy of this file descriptor, closing fd first if
-  // necessary.
-  void dup2(int fd);
-
-  // Makes fd be the copy of this file descriptor, closing fd first if
-  // necessary.
-  void dup2(int fd, std::error_code& ec) noexcept;
-
-  // Creates a buffered_file object associated with this file and detaches
-  // this file object from the file.
-  auto fdopen(const char* mode) -> buffered_file;
-
-#  if defined(_WIN32) && !defined(__MINGW32__)
-  // Opens a file and constructs a file object representing this file by
-  // wcstring_view filename. Windows only.
-  static file open_windows_file(wcstring_view path, int oflag);
-#  endif
-};
-
-struct FMT_API pipe {
-  file read_end;
-  file write_end;
-
-  // Creates a pipe setting up read_end and write_end file objects for reading
-  // and writing respectively.
-  pipe();
-};
-
-// Returns the memory page size.
-auto getpagesize() -> long;
-
-namespace detail {
-
-struct buffer_size {
-  constexpr buffer_size() = default;
-  size_t value = 0;
-  FMT_CONSTEXPR auto operator=(size_t val) const -> buffer_size {
-    auto bs = buffer_size();
-    bs.value = val;
-    return bs;
-  }
-};
-
-struct ostream_params {
-  int oflag = file::WRONLY | file::CREATE | file::TRUNC;
-  size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768;
-
-  constexpr ostream_params() {}
-
-  template <typename... T>
-  ostream_params(T... params, int new_oflag) : ostream_params(params...) {
-    oflag = new_oflag;
-  }
-
-  template <typename... T>
-  ostream_params(T... params, detail::buffer_size bs)
-      : ostream_params(params...) {
-    this->buffer_size = bs.value;
-  }
-
-// Intel has a bug that results in failure to deduce a constructor
-// for empty parameter packs.
-#  if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 2000
-  ostream_params(int new_oflag) : oflag(new_oflag) {}
-  ostream_params(detail::buffer_size bs) : buffer_size(bs.value) {}
-#  endif
-};
-
-}  // namespace detail
-
-FMT_INLINE_VARIABLE constexpr auto buffer_size = detail::buffer_size();
-
-/// A fast buffered output stream for writing from a single thread. Writing from
-/// multiple threads without external synchronization may result in a data race.
-class FMT_API ostream : private detail::buffer<char> {
- private:
-  file file_;
-
-  ostream(cstring_view path, const detail::ostream_params& params);
-
-  static void grow(buffer<char>& buf, size_t);
-
- public:
-  ostream(ostream&& other) noexcept;
-  ~ostream();
-
-  operator writer() {
-    detail::buffer<char>& buf = *this;
-    return buf;
-  }
-
-  inline void flush() {
-    if (size() == 0) return;
-    file_.write(data(), size() * sizeof(data()[0]));
-    clear();
-  }
-
-  template <typename... T>
-  friend auto output_file(cstring_view path, T... params) -> ostream;
-
-  inline void close() {
-    flush();
-    file_.close();
-  }
-
-  /// Formats `args` according to specifications in `fmt` and writes the
-  /// output to the file.
-  template <typename... T> void print(format_string<T...> fmt, T&&... args) {
-    vformat_to(appender(*this), fmt.str, vargs<T...>{{args...}});
-  }
-};
-
-/**
- * Opens a file for writing. Supported parameters passed in `params`:
- *
- * - `<integer>`: Flags passed to [open](
- *   https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html)
- *   (`file::WRONLY | file::CREATE | file::TRUNC` by default)
- * - `buffer_size=<integer>`: Output buffer size
- *
- * **Example**:
- *
- *     auto out = fmt::output_file("guide.txt");
- *     out.print("Don't {}", "Panic");
- */
-template <typename... T>
-inline auto output_file(cstring_view path, T... params) -> ostream {
-  return {path, detail::ostream_params(params...)};
-}
-#endif  // FMT_USE_FCNTL
-
-FMT_END_EXPORT
-FMT_END_NAMESPACE
-
-#endif  // FMT_OS_H_
@@ -1,167 +0,0 @@
-// Formatting library for C++ - std::ostream support
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_OSTREAM_H_
-#define FMT_OSTREAM_H_
-
-#ifndef FMT_MODULE
-#  include <fstream>  // std::filebuf
-#endif
-
-#ifdef _WIN32
-#  ifdef __GLIBCXX__
-#    include <ext/stdio_filebuf.h>
-#    include <ext/stdio_sync_filebuf.h>
-#  endif
-#  include <io.h>
-#endif
-
-#include "chrono.h"  // formatbuf
-
-#ifdef _MSVC_STL_UPDATE
-#  define FMT_MSVC_STL_UPDATE _MSVC_STL_UPDATE
-#elif defined(_MSC_VER) && _MSC_VER < 1912  // VS 15.5
-#  define FMT_MSVC_STL_UPDATE _MSVC_LANG
-#else
-#  define FMT_MSVC_STL_UPDATE 0
-#endif
-
-FMT_BEGIN_NAMESPACE
-namespace detail {
-
-// Generate a unique explicit instantion in every translation unit using a tag
-// type in an anonymous namespace.
-namespace {
-struct file_access_tag {};
-}  // namespace
-template <typename Tag, typename BufType, FILE* BufType::*FileMemberPtr>
-class file_access {
-  friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; }
-};
-
-#if FMT_MSVC_STL_UPDATE
-template class file_access<file_access_tag, std::filebuf,
-                           &std::filebuf::_Myfile>;
-auto get_file(std::filebuf&) -> FILE*;
-#endif
-
-// Write the content of buf to os.
-// It is a separate function rather than a part of vprint to simplify testing.
-template <typename Char>
-void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
-  const Char* buf_data = buf.data();
-  using unsigned_streamsize = make_unsigned_t<std::streamsize>;
-  unsigned_streamsize size = buf.size();
-  unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
-  do {
-    unsigned_streamsize n = size <= max_size ? size : max_size;
-    os.write(buf_data, static_cast<std::streamsize>(n));
-    buf_data += n;
-    size -= n;
-  } while (size != 0);
-}
-
-template <typename T> struct streamed_view {
-  const T& value;
-};
-}  // namespace detail
-
-// Formats an object of type T that has an overloaded ostream operator<<.
-template <typename Char>
-struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
-  void set_debug_format() = delete;
-
-  template <typename T, typename Context>
-  auto format(const T& value, Context& ctx) const -> decltype(ctx.out()) {
-    auto buffer = basic_memory_buffer<Char>();
-    auto&& formatbuf = detail::formatbuf<std::basic_streambuf<Char>>(buffer);
-    auto&& output = std::basic_ostream<Char>(&formatbuf);
-    output.imbue(std::locale::classic());  // The default is always unlocalized.
-    output << value;
-    output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
-    return formatter<basic_string_view<Char>, Char>::format(
-        {buffer.data(), buffer.size()}, ctx);
-  }
-};
-
-using ostream_formatter = basic_ostream_formatter<char>;
-
-template <typename T, typename Char>
-struct formatter<detail::streamed_view<T>, Char>
-    : basic_ostream_formatter<Char> {
-  template <typename Context>
-  auto format(detail::streamed_view<T> view, Context& ctx) const
-      -> decltype(ctx.out()) {
-    return basic_ostream_formatter<Char>::format(view.value, ctx);
-  }
-};
-
-/**
- * Returns a view that formats `value` via an ostream `operator<<`.
- *
- * **Example**:
- *
- *     fmt::print("Current thread id: {}\n",
- *                fmt::streamed(std::this_thread::get_id()));
- */
-template <typename T>
-constexpr auto streamed(const T& value) -> detail::streamed_view<T> {
-  return {value};
-}
-
-inline void vprint(std::ostream& os, string_view fmt, format_args args) {
-  auto buffer = memory_buffer();
-  detail::vformat_to(buffer, fmt, args);
-  FILE* f = nullptr;
-#if FMT_MSVC_STL_UPDATE && FMT_USE_RTTI
-  if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
-    f = detail::get_file(*buf);
-#elif defined(_WIN32) && defined(__GLIBCXX__) && FMT_USE_RTTI
-  auto* rdbuf = os.rdbuf();
-  if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
-    f = sfbuf->file();
-  else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
-    f = fbuf->file();
-#endif
-#ifdef _WIN32
-  if (f) {
-    int fd = _fileno(f);
-    if (_isatty(fd)) {
-      os.flush();
-      if (detail::write_console(fd, {buffer.data(), buffer.size()})) return;
-    }
-  }
-#endif
-  detail::ignore_unused(f);
-  detail::write_buffer(os, buffer);
-}
-
-/**
- * Prints formatted data to the stream `os`.
- *
- * **Example**:
- *
- *     fmt::print(cerr, "Don't {}!", "panic");
- */
-FMT_EXPORT template <typename... T>
-void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
-  fmt::vargs<T...> vargs = {{args...}};
-  if (detail::const_check(detail::use_utf8)) return vprint(os, fmt.str, vargs);
-  auto buffer = memory_buffer();
-  detail::vformat_to(buffer, fmt.str, vargs);
-  detail::write_buffer(os, buffer);
-}
-
-FMT_EXPORT template <typename... T>
-void println(std::ostream& os, format_string<T...> fmt, T&&... args) {
-  fmt::print(os, FMT_STRING("{}\n"),
-             fmt::format(fmt, std::forward<T>(args)...));
-}
-
-FMT_END_NAMESPACE
-
-#endif  // FMT_OSTREAM_H_
@@ -1,633 +0,0 @@
-// Formatting library for C++ - legacy printf implementation
-//
-// Copyright (c) 2012 - 2016, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_PRINTF_H_
-#define FMT_PRINTF_H_
-
-#ifndef FMT_MODULE
-#  include <algorithm>  // std::max
-#  include <limits>     // std::numeric_limits
-#endif
-
-#include "format.h"
-
-FMT_BEGIN_NAMESPACE
-FMT_BEGIN_EXPORT
-
-template <typename T> struct printf_formatter {
-  printf_formatter() = delete;
-};
-
-template <typename Char> class basic_printf_context {
- private:
-  basic_appender<Char> out_;
-  basic_format_args<basic_printf_context> args_;
-
-  static_assert(std::is_same<Char, char>::value ||
-                    std::is_same<Char, wchar_t>::value,
-                "Unsupported code unit type.");
-
- public:
-  using char_type = Char;
-  using parse_context_type = parse_context<Char>;
-  template <typename T> using formatter_type = printf_formatter<T>;
-  enum { builtin_types = 1 };
-
-  /// Constructs a `printf_context` object. References to the arguments are
-  /// stored in the context object so make sure they have appropriate lifetimes.
-  basic_printf_context(basic_appender<Char> out,
-                       basic_format_args<basic_printf_context> args)
-      : out_(out), args_(args) {}
-
-  auto out() -> basic_appender<Char> { return out_; }
-  void advance_to(basic_appender<Char>) {}
-
-  auto locale() -> detail::locale_ref { return {}; }
-
-  auto arg(int id) const -> basic_format_arg<basic_printf_context> {
-    return args_.get(id);
-  }
-};
-
-namespace detail {
-
-// Return the result via the out param to workaround gcc bug 77539.
-template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
-FMT_CONSTEXPR auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool {
-  for (out = first; out != last; ++out) {
-    if (*out == value) return true;
-  }
-  return false;
-}
-
-template <>
-inline auto find<false, char>(const char* first, const char* last, char value,
-                              const char*& out) -> bool {
-  out =
-      static_cast<const char*>(memchr(first, value, to_unsigned(last - first)));
-  return out != nullptr;
-}
-
-// Checks if a value fits in int - used to avoid warnings about comparing
-// signed and unsigned integers.
-template <bool IsSigned> struct int_checker {
-  template <typename T> static auto fits_in_int(T value) -> bool {
-    unsigned max = to_unsigned(max_value<int>());
-    return value <= max;
-  }
-  inline static auto fits_in_int(bool) -> bool { return true; }
-};
-
-template <> struct int_checker<true> {
-  template <typename T> static auto fits_in_int(T value) -> bool {
-    return value >= (std::numeric_limits<int>::min)() &&
-           value <= max_value<int>();
-  }
-  inline static auto fits_in_int(int) -> bool { return true; }
-};
-
-struct printf_precision_handler {
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  auto operator()(T value) -> int {
-    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      report_error("number is too big");
-    return (std::max)(static_cast<int>(value), 0);
-  }
-
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  auto operator()(T) -> int {
-    report_error("precision is not integer");
-    return 0;
-  }
-};
-
-// An argument visitor that returns true iff arg is a zero integer.
-struct is_zero_int {
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  auto operator()(T value) -> bool {
-    return value == 0;
-  }
-
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  auto operator()(T) -> bool {
-    return false;
-  }
-};
-
-template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};
-
-template <> struct make_unsigned_or_bool<bool> {
-  using type = bool;
-};
-
-template <typename T, typename Context> class arg_converter {
- private:
-  using char_type = typename Context::char_type;
-
-  basic_format_arg<Context>& arg_;
-  char_type type_;
-
- public:
-  arg_converter(basic_format_arg<Context>& arg, char_type type)
-      : arg_(arg), type_(type) {}
-
-  void operator()(bool value) {
-    if (type_ != 's') operator()<bool>(value);
-  }
-
-  template <typename U, FMT_ENABLE_IF(std::is_integral<U>::value)>
-  void operator()(U value) {
-    bool is_signed = type_ == 'd' || type_ == 'i';
-    using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
-    if (const_check(sizeof(target_type) <= sizeof(int))) {
-      // Extra casts are used to silence warnings.
-      using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
-      if (is_signed)
-        arg_ = static_cast<int>(static_cast<target_type>(value));
-      else
-        arg_ = static_cast<unsigned>(static_cast<unsigned_type>(value));
-    } else {
-      // glibc's printf doesn't sign extend arguments of smaller types:
-      //   std::printf("%lld", -42);  // prints "4294967254"
-      // but we don't have to do the same because it's a UB.
-      if (is_signed)
-        arg_ = static_cast<long long>(value);
-      else
-        arg_ = static_cast<typename make_unsigned_or_bool<U>::type>(value);
-    }
-  }
-
-  template <typename U, FMT_ENABLE_IF(!std::is_integral<U>::value)>
-  void operator()(U) {}  // No conversion needed for non-integral types.
-};
-
-// Converts an integer argument to T for printf, if T is an integral type.
-// If T is void, the argument is converted to corresponding signed or unsigned
-// type depending on the type specifier: 'd' and 'i' - signed, other -
-// unsigned).
-template <typename T, typename Context, typename Char>
-void convert_arg(basic_format_arg<Context>& arg, Char type) {
-  arg.visit(arg_converter<T, Context>(arg, type));
-}
-
-// Converts an integer argument to char for printf.
-template <typename Context> class char_converter {
- private:
-  basic_format_arg<Context>& arg_;
-
- public:
-  explicit char_converter(basic_format_arg<Context>& arg) : arg_(arg) {}
-
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  void operator()(T value) {
-    arg_ = static_cast<typename Context::char_type>(value);
-  }
-
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  void operator()(T) {}  // No conversion needed for non-integral types.
-};
-
-// An argument visitor that return a pointer to a C string if argument is a
-// string or null otherwise.
-template <typename Char> struct get_cstring {
-  template <typename T> auto operator()(T) -> const Char* { return nullptr; }
-  auto operator()(const Char* s) -> const Char* { return s; }
-};
-
-// Checks if an argument is a valid printf width specifier and sets
-// left alignment if it is negative.
-class printf_width_handler {
- private:
-  format_specs& specs_;
-
- public:
-  inline explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
-
-  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  auto operator()(T value) -> unsigned {
-    auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
-    if (detail::is_negative(value)) {
-      specs_.set_align(align::left);
-      width = 0 - width;
-    }
-    unsigned int_max = to_unsigned(max_value<int>());
-    if (width > int_max) report_error("number is too big");
-    return static_cast<unsigned>(width);
-  }
-
-  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  auto operator()(T) -> unsigned {
-    report_error("width is not integer");
-    return 0;
-  }
-};
-
-// Workaround for a bug with the XL compiler when initializing
-// printf_arg_formatter's base class.
-template <typename Char>
-auto make_arg_formatter(basic_appender<Char> iter, format_specs& s)
-    -> arg_formatter<Char> {
-  return {iter, s, locale_ref()};
-}
-
-// The `printf` argument formatter.
-template <typename Char>
-class printf_arg_formatter : public arg_formatter<Char> {
- private:
-  using base = arg_formatter<Char>;
-  using context_type = basic_printf_context<Char>;
-
-  context_type& context_;
-
-  void write_null_pointer(bool is_string = false) {
-    auto s = this->specs;
-    s.set_type(presentation_type::none);
-    write_bytes<Char>(this->out, is_string ? "(null)" : "(nil)", s);
-  }
-
-  template <typename T> void write(T value) {
-    detail::write<Char>(this->out, value, this->specs, this->locale);
-  }
-
- public:
-  printf_arg_formatter(basic_appender<Char> iter, format_specs& s,
-                       context_type& ctx)
-      : base(make_arg_formatter(iter, s)), context_(ctx) {}
-
-  void operator()(monostate value) { write(value); }
-
-  template <typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)>
-  void operator()(T value) {
-    // MSVC2013 fails to compile separate overloads for bool and Char so use
-    // std::is_same instead.
-    if (!std::is_same<T, Char>::value) {
-      write(value);
-      return;
-    }
-    format_specs s = this->specs;
-    if (s.type() != presentation_type::none &&
-        s.type() != presentation_type::chr) {
-      return (*this)(static_cast<int>(value));
-    }
-    s.set_sign(sign::none);
-    s.clear_alt();
-    s.set_fill(' ');  // Ignore '0' flag for char types.
-    // align::numeric needs to be overwritten here since the '0' flag is
-    // ignored for non-numeric types
-    if (s.align() == align::none || s.align() == align::numeric)
-      s.set_align(align::right);
-    detail::write<Char>(this->out, static_cast<Char>(value), s);
-  }
-
-  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-  void operator()(T value) {
-    write(value);
-  }
-
-  void operator()(const char* value) {
-    if (value)
-      write(value);
-    else
-      write_null_pointer(this->specs.type() != presentation_type::pointer);
-  }
-
-  void operator()(const wchar_t* value) {
-    if (value)
-      write(value);
-    else
-      write_null_pointer(this->specs.type() != presentation_type::pointer);
-  }
-
-  void operator()(basic_string_view<Char> value) { write(value); }
-
-  void operator()(const void* value) {
-    if (value)
-      write(value);
-    else
-      write_null_pointer();
-  }
-
-  void operator()(typename basic_format_arg<context_type>::handle handle) {
-    auto parse_ctx = parse_context<Char>({});
-    handle.format(parse_ctx, context_);
-  }
-};
-
-template <typename Char>
-void parse_flags(format_specs& specs, const Char*& it, const Char* end) {
-  for (; it != end; ++it) {
-    switch (*it) {
-    case '-': specs.set_align(align::left); break;
-    case '+': specs.set_sign(sign::plus); break;
-    case '0': specs.set_fill('0'); break;
-    case ' ':
-      if (specs.sign() != sign::plus) specs.set_sign(sign::space);
-      break;
-    case '#': specs.set_alt(); break;
-    default:  return;
-    }
-  }
-}
-
-template <typename Char, typename GetArg>
-auto parse_header(const Char*& it, const Char* end, format_specs& specs,
-                  GetArg get_arg) -> int {
-  int arg_index = -1;
-  Char c = *it;
-  if (c >= '0' && c <= '9') {
-    // Parse an argument index (if followed by '$') or a width possibly
-    // preceded with '0' flag(s).
-    int value = parse_nonnegative_int(it, end, -1);
-    if (it != end && *it == '$') {  // value is an argument index
-      ++it;
-      arg_index = value != -1 ? value : max_value<int>();
-    } else {
-      if (c == '0') specs.set_fill('0');
-      if (value != 0) {
-        // Nonzero value means that we parsed width and don't need to
-        // parse it or flags again, so return now.
-        if (value == -1) report_error("number is too big");
-        specs.width = value;
-        return arg_index;
-      }
-    }
-  }
-  parse_flags(specs, it, end);
-  // Parse width.
-  if (it != end) {
-    if (*it >= '0' && *it <= '9') {
-      specs.width = parse_nonnegative_int(it, end, -1);
-      if (specs.width == -1) report_error("number is too big");
-    } else if (*it == '*') {
-      ++it;
-      specs.width = static_cast<int>(
-          get_arg(-1).visit(detail::printf_width_handler(specs)));
-    }
-  }
-  return arg_index;
-}
-
-inline auto parse_printf_presentation_type(char c, type t, bool& upper)
-    -> presentation_type {
-  using pt = presentation_type;
-  constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
-  switch (c) {
-  case 'd': return in(t, integral_set) ? pt::dec : pt::none;
-  case 'o': return in(t, integral_set) ? pt::oct : pt::none;
-  case 'X': upper = true; FMT_FALLTHROUGH;
-  case 'x': return in(t, integral_set) ? pt::hex : pt::none;
-  case 'E': upper = true; FMT_FALLTHROUGH;
-  case 'e': return in(t, float_set) ? pt::exp : pt::none;
-  case 'F': upper = true; FMT_FALLTHROUGH;
-  case 'f': return in(t, float_set) ? pt::fixed : pt::none;
-  case 'G': upper = true; FMT_FALLTHROUGH;
-  case 'g': return in(t, float_set) ? pt::general : pt::none;
-  case 'A': upper = true; FMT_FALLTHROUGH;
-  case 'a': return in(t, float_set) ? pt::hexfloat : pt::none;
-  case 'c': return in(t, integral_set) ? pt::chr : pt::none;
-  case 's': return in(t, string_set | cstring_set) ? pt::string : pt::none;
-  case 'p': return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none;
-  default:  return pt::none;
-  }
-}
-
-template <typename Char, typename Context>
-void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
-             basic_format_args<Context> args) {
-  using iterator = basic_appender<Char>;
-  auto out = iterator(buf);
-  auto context = basic_printf_context<Char>(out, args);
-  auto parse_ctx = parse_context<Char>(format);
-
-  // Returns the argument with specified index or, if arg_index is -1, the next
-  // argument.
-  auto get_arg = [&](int arg_index) {
-    if (arg_index < 0)
-      arg_index = parse_ctx.next_arg_id();
-    else
-      parse_ctx.check_arg_id(--arg_index);
-    return detail::get_arg(context, arg_index);
-  };
-
-  const Char* start = parse_ctx.begin();
-  const Char* end = parse_ctx.end();
-  auto it = start;
-  while (it != end) {
-    if (!find<false, Char>(it, end, '%', it)) {
-      it = end;  // find leaves it == nullptr if it doesn't find '%'.
-      break;
-    }
-    Char c = *it++;
-    if (it != end && *it == c) {
-      write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
-      start = ++it;
-      continue;
-    }
-    write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start)));
-
-    auto specs = format_specs();
-    specs.set_align(align::right);
-
-    // Parse argument index, flags and width.
-    int arg_index = parse_header(it, end, specs, get_arg);
-    if (arg_index == 0) report_error("argument not found");
-
-    // Parse precision.
-    if (it != end && *it == '.') {
-      ++it;
-      c = it != end ? *it : 0;
-      if ('0' <= c && c <= '9') {
-        specs.precision = parse_nonnegative_int(it, end, 0);
-      } else if (c == '*') {
-        ++it;
-        specs.precision =
-            static_cast<int>(get_arg(-1).visit(printf_precision_handler()));
-      } else {
-        specs.precision = 0;
-      }
-    }
-
-    auto arg = get_arg(arg_index);
-    // For d, i, o, u, x, and X conversion specifiers, if a precision is
-    // specified, the '0' flag is ignored
-    if (specs.precision >= 0 && is_integral_type(arg.type())) {
-      // Ignore '0' for non-numeric types or if '-' present.
-      specs.set_fill(' ');
-    }
-    if (specs.precision >= 0 && arg.type() == type::cstring_type) {
-      auto str = arg.visit(get_cstring<Char>());
-      auto str_end = str + specs.precision;
-      auto nul = std::find(str, str_end, Char());
-      auto sv = basic_string_view<Char>(
-          str, to_unsigned(nul != str_end ? nul - str : specs.precision));
-      arg = sv;
-    }
-    if (specs.alt() && arg.visit(is_zero_int())) specs.clear_alt();
-    if (specs.fill_unit<Char>() == '0') {
-      if (is_arithmetic_type(arg.type()) && specs.align() != align::left) {
-        specs.set_align(align::numeric);
-      } else {
-        // Ignore '0' flag for non-numeric types or if '-' flag is also present.
-        specs.set_fill(' ');
-      }
-    }
-
-    // Parse length and convert the argument to the required type.
-    c = it != end ? *it++ : 0;
-    Char t = it != end ? *it : 0;
-    switch (c) {
-    case 'h':
-      if (t == 'h') {
-        ++it;
-        t = it != end ? *it : 0;
-        convert_arg<signed char>(arg, t);
-      } else {
-        convert_arg<short>(arg, t);
-      }
-      break;
-    case 'l':
-      if (t == 'l') {
-        ++it;
-        t = it != end ? *it : 0;
-        convert_arg<long long>(arg, t);
-      } else {
-        convert_arg<long>(arg, t);
-      }
-      break;
-    case 'j': convert_arg<intmax_t>(arg, t); break;
-    case 'z': convert_arg<size_t>(arg, t); break;
-    case 't': convert_arg<std::ptrdiff_t>(arg, t); break;
-    case 'L':
-      // printf produces garbage when 'L' is omitted for long double, no
-      // need to do the same.
-      break;
-    default: --it; convert_arg<void>(arg, c);
-    }
-
-    // Parse type.
-    if (it == end) report_error("invalid format string");
-    char type = static_cast<char>(*it++);
-    if (is_integral_type(arg.type())) {
-      // Normalize type.
-      switch (type) {
-      case 'i':
-      case 'u': type = 'd'; break;
-      case 'c':
-        arg.visit(char_converter<basic_printf_context<Char>>(arg));
-        break;
-      }
-    }
-    bool upper = false;
-    specs.set_type(parse_printf_presentation_type(type, arg.type(), upper));
-    if (specs.type() == presentation_type::none)
-      report_error("invalid format specifier");
-    if (upper) specs.set_upper();
-
-    start = it;
-
-    // Format argument.
-    arg.visit(printf_arg_formatter<Char>(out, specs, context));
-  }
-  write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
-}
-}  // namespace detail
-
-using printf_context = basic_printf_context<char>;
-using wprintf_context = basic_printf_context<wchar_t>;
-
-using printf_args = basic_format_args<printf_context>;
-using wprintf_args = basic_format_args<wprintf_context>;
-
-/// Constructs an `format_arg_store` object that contains references to
-/// arguments and can be implicitly converted to `printf_args`.
-template <typename Char = char, typename... T>
-inline auto make_printf_args(T&... args)
-    -> decltype(fmt::make_format_args<basic_printf_context<Char>>(args...)) {
-  return fmt::make_format_args<basic_printf_context<Char>>(args...);
-}
-
-template <typename Char> struct vprintf_args {
-  using type = basic_format_args<basic_printf_context<Char>>;
-};
-
-template <typename Char>
-inline auto vsprintf(basic_string_view<Char> fmt,
-                     typename vprintf_args<Char>::type args)
-    -> std::basic_string<Char> {
-  auto buf = basic_memory_buffer<Char>();
-  detail::vprintf(buf, fmt, args);
-  return {buf.data(), buf.size()};
-}
-
-/**
- * Formats `args` according to specifications in `fmt` and returns the result
- * as as string.
- *
- * **Example**:
- *
- *     std::string message = fmt::sprintf("The answer is %d", 42);
- */
-template <typename S, typename... T, typename Char = detail::char_t<S>>
-inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> {
-  return vsprintf(detail::to_string_view(fmt),
-                  fmt::make_format_args<basic_printf_context<Char>>(args...));
-}
-
-template <typename Char>
-inline auto vfprintf(std::FILE* f, basic_string_view<Char> fmt,
-                     typename vprintf_args<Char>::type args) -> int {
-  auto buf = basic_memory_buffer<Char>();
-  detail::vprintf(buf, fmt, args);
-  size_t size = buf.size();
-  return std::fwrite(buf.data(), sizeof(Char), size, f) < size
-             ? -1
-             : static_cast<int>(size);
-}
-
-/**
- * Formats `args` according to specifications in `fmt` and writes the output
- * to `f`.
- *
- * **Example**:
- *
- *     fmt::fprintf(stderr, "Don't %s!", "panic");
- */
-template <typename S, typename... T, typename Char = detail::char_t<S>>
-inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int {
-  return vfprintf(f, detail::to_string_view(fmt),
-                  make_printf_args<Char>(args...));
-}
-
-template <typename Char>
-FMT_DEPRECATED inline auto vprintf(basic_string_view<Char> fmt,
-                                   typename vprintf_args<Char>::type args)
-    -> int {
-  return vfprintf(stdout, fmt, args);
-}
-
-/**
- * Formats `args` according to specifications in `fmt` and writes the output
- * to `stdout`.
- *
- * **Example**:
- *
- *   fmt::printf("Elapsed time: %.2f seconds", 1.23);
- */
-template <typename... T>
-inline auto printf(string_view fmt, const T&... args) -> int {
-  return vfprintf(stdout, fmt, make_printf_args(args...));
-}
-template <typename... T>
-FMT_DEPRECATED inline auto printf(basic_string_view<wchar_t> fmt,
-                                  const T&... args) -> int {
-  return vfprintf(stdout, fmt, make_printf_args<wchar_t>(args...));
-}
-
-FMT_END_EXPORT
-FMT_END_NAMESPACE
-
-#endif  // FMT_PRINTF_H_
@@ -1,850 +0,0 @@
-// Formatting library for C++ - range and tuple support
-//
-// Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_RANGES_H_
-#define FMT_RANGES_H_
-
-#ifndef FMT_MODULE
-#  include <initializer_list>
-#  include <iterator>
-#  include <string>
-#  include <tuple>
-#  include <type_traits>
-#  include <utility>
-#endif
-
-#include "format.h"
-
-FMT_BEGIN_NAMESPACE
-
-FMT_EXPORT
-enum class range_format { disabled, map, set, sequence, string, debug_string };
-
-namespace detail {
-
-template <typename T> class is_map {
-  template <typename U> static auto check(U*) -> typename U::mapped_type;
-  template <typename> static void check(...);
-
- public:
-  static constexpr const bool value =
-      !std::is_void<decltype(check<T>(nullptr))>::value;
-};
-
-template <typename T> class is_set {
-  template <typename U> static auto check(U*) -> typename U::key_type;
-  template <typename> static void check(...);
-
- public:
-  static constexpr const bool value =
-      !std::is_void<decltype(check<T>(nullptr))>::value && !is_map<T>::value;
-};
-
-// C array overload
-template <typename T, std::size_t N>
-auto range_begin(const T (&arr)[N]) -> const T* {
-  return arr;
-}
-template <typename T, std::size_t N>
-auto range_end(const T (&arr)[N]) -> const T* {
-  return arr + N;
-}
-
-template <typename T, typename Enable = void>
-struct has_member_fn_begin_end_t : std::false_type {};
-
-template <typename T>
-struct has_member_fn_begin_end_t<T, void_t<decltype(*std::declval<T>().begin()),
-                                           decltype(std::declval<T>().end())>>
-    : std::true_type {};
-
-// Member function overloads.
-template <typename T>
-auto range_begin(T&& rng) -> decltype(static_cast<T&&>(rng).begin()) {
-  return static_cast<T&&>(rng).begin();
-}
-template <typename T>
-auto range_end(T&& rng) -> decltype(static_cast<T&&>(rng).end()) {
-  return static_cast<T&&>(rng).end();
-}
-
-// ADL overloads. Only participate in overload resolution if member functions
-// are not found.
-template <typename T>
-auto range_begin(T&& rng)
-    -> enable_if_t<!has_member_fn_begin_end_t<T&&>::value,
-                   decltype(begin(static_cast<T&&>(rng)))> {
-  return begin(static_cast<T&&>(rng));
-}
-template <typename T>
-auto range_end(T&& rng) -> enable_if_t<!has_member_fn_begin_end_t<T&&>::value,
-                                       decltype(end(static_cast<T&&>(rng)))> {
-  return end(static_cast<T&&>(rng));
-}
-
-template <typename T, typename Enable = void>
-struct has_const_begin_end : std::false_type {};
-template <typename T, typename Enable = void>
-struct has_mutable_begin_end : std::false_type {};
-
-template <typename T>
-struct has_const_begin_end<
-    T, void_t<decltype(*detail::range_begin(
-                  std::declval<const remove_cvref_t<T>&>())),
-              decltype(detail::range_end(
-                  std::declval<const remove_cvref_t<T>&>()))>>
-    : std::true_type {};
-
-template <typename T>
-struct has_mutable_begin_end<
-    T, void_t<decltype(*detail::range_begin(std::declval<T&>())),
-              decltype(detail::range_end(std::declval<T&>())),
-              // the extra int here is because older versions of MSVC don't
-              // SFINAE properly unless there are distinct types
-              int>> : std::true_type {};
-
-template <typename T, typename _ = void> struct is_range_ : std::false_type {};
-template <typename T>
-struct is_range_<T, void>
-    : std::integral_constant<bool, (has_const_begin_end<T>::value ||
-                                    has_mutable_begin_end<T>::value)> {};
-
-// tuple_size and tuple_element check.
-template <typename T> class is_tuple_like_ {
-  template <typename U, typename V = typename std::remove_cv<U>::type>
-  static auto check(U* p) -> decltype(std::tuple_size<V>::value, 0);
-  template <typename> static void check(...);
-
- public:
-  static constexpr const bool value =
-      !std::is_void<decltype(check<T>(nullptr))>::value;
-};
-
-// Check for integer_sequence
-#if defined(__cpp_lib_integer_sequence) || FMT_MSC_VERSION >= 1900
-template <typename T, T... N>
-using integer_sequence = std::integer_sequence<T, N...>;
-template <size_t... N> using index_sequence = std::index_sequence<N...>;
-template <size_t N> using make_index_sequence = std::make_index_sequence<N>;
-#else
-template <typename T, T... N> struct integer_sequence {
-  using value_type = T;
-
-  static FMT_CONSTEXPR auto size() -> size_t { return sizeof...(N); }
-};
-
-template <size_t... N> using index_sequence = integer_sequence<size_t, N...>;
-
-template <typename T, size_t N, T... Ns>
-struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...> {};
-template <typename T, T... Ns>
-struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...> {};
-
-template <size_t N>
-using make_index_sequence = make_integer_sequence<size_t, N>;
-#endif
-
-template <typename T>
-using tuple_index_sequence = make_index_sequence<std::tuple_size<T>::value>;
-
-template <typename T, typename C, bool = is_tuple_like_<T>::value>
-class is_tuple_formattable_ {
- public:
-  static constexpr const bool value = false;
-};
-template <typename T, typename C> class is_tuple_formattable_<T, C, true> {
-  template <size_t... Is>
-  static auto all_true(index_sequence<Is...>,
-                       integer_sequence<bool, (Is >= 0)...>) -> std::true_type;
-  static auto all_true(...) -> std::false_type;
-
-  template <size_t... Is>
-  static auto check(index_sequence<Is...>) -> decltype(all_true(
-      index_sequence<Is...>{},
-      integer_sequence<bool,
-                       (is_formattable<typename std::tuple_element<Is, T>::type,
-                                       C>::value)...>{}));
-
- public:
-  static constexpr const bool value =
-      decltype(check(tuple_index_sequence<T>{}))::value;
-};
-
-template <typename Tuple, typename F, size_t... Is>
-FMT_CONSTEXPR void for_each(index_sequence<Is...>, Tuple&& t, F&& f) {
-  using std::get;
-  // Using a free function get<Is>(Tuple) now.
-  const int unused[] = {0, ((void)f(get<Is>(t)), 0)...};
-  ignore_unused(unused);
-}
-
-template <typename Tuple, typename F>
-FMT_CONSTEXPR void for_each(Tuple&& t, F&& f) {
-  for_each(tuple_index_sequence<remove_cvref_t<Tuple>>(),
-           std::forward<Tuple>(t), std::forward<F>(f));
-}
-
-template <typename Tuple1, typename Tuple2, typename F, size_t... Is>
-void for_each2(index_sequence<Is...>, Tuple1&& t1, Tuple2&& t2, F&& f) {
-  using std::get;
-  const int unused[] = {0, ((void)f(get<Is>(t1), get<Is>(t2)), 0)...};
-  ignore_unused(unused);
-}
-
-template <typename Tuple1, typename Tuple2, typename F>
-void for_each2(Tuple1&& t1, Tuple2&& t2, F&& f) {
-  for_each2(tuple_index_sequence<remove_cvref_t<Tuple1>>(),
-            std::forward<Tuple1>(t1), std::forward<Tuple2>(t2),
-            std::forward<F>(f));
-}
-
-namespace tuple {
-// Workaround a bug in MSVC 2019 (v140).
-template <typename Char, typename... T>
-using result_t = std::tuple<formatter<remove_cvref_t<T>, Char>...>;
-
-using std::get;
-template <typename Tuple, typename Char, std::size_t... Is>
-auto get_formatters(index_sequence<Is...>)
-    -> result_t<Char, decltype(get<Is>(std::declval<Tuple>()))...>;
-}  // namespace tuple
-
-#if FMT_MSC_VERSION && FMT_MSC_VERSION < 1920
-// Older MSVC doesn't get the reference type correctly for arrays.
-template <typename R> struct range_reference_type_impl {
-  using type = decltype(*detail::range_begin(std::declval<R&>()));
-};
-
-template <typename T, std::size_t N> struct range_reference_type_impl<T[N]> {
-  using type = T&;
-};
-
-template <typename T>
-using range_reference_type = typename range_reference_type_impl<T>::type;
-#else
-template <typename Range>
-using range_reference_type =
-    decltype(*detail::range_begin(std::declval<Range&>()));
-#endif
-
-// We don't use the Range's value_type for anything, but we do need the Range's
-// reference type, with cv-ref stripped.
-template <typename Range>
-using uncvref_type = remove_cvref_t<range_reference_type<Range>>;
-
-template <typename Formatter>
-FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set)
-    -> decltype(f.set_debug_format(set)) {
-  f.set_debug_format(set);
-}
-template <typename Formatter>
-FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {}
-
-template <typename T>
-struct range_format_kind_
-    : std::integral_constant<range_format,
-                             std::is_same<uncvref_type<T>, T>::value
-                                 ? range_format::disabled
-                             : is_map<T>::value ? range_format::map
-                             : is_set<T>::value ? range_format::set
-                                                : range_format::sequence> {};
-
-template <range_format K>
-using range_format_constant = std::integral_constant<range_format, K>;
-
-// These are not generic lambdas for compatibility with C++11.
-template <typename Char> struct parse_empty_specs {
-  template <typename Formatter> FMT_CONSTEXPR void operator()(Formatter& f) {
-    f.parse(ctx);
-    detail::maybe_set_debug_format(f, true);
-  }
-  parse_context<Char>& ctx;
-};
-template <typename FormatContext> struct format_tuple_element {
-  using char_type = typename FormatContext::char_type;
-
-  template <typename T>
-  void operator()(const formatter<T, char_type>& f, const T& v) {
-    if (i > 0) ctx.advance_to(detail::copy<char_type>(separator, ctx.out()));
-    ctx.advance_to(f.format(v, ctx));
-    ++i;
-  }
-
-  int i;
-  FormatContext& ctx;
-  basic_string_view<char_type> separator;
-};
-
-}  // namespace detail
-
-template <typename T> struct is_tuple_like {
-  static constexpr const bool value =
-      detail::is_tuple_like_<T>::value && !detail::is_range_<T>::value;
-};
-
-template <typename T, typename C> struct is_tuple_formattable {
-  static constexpr const bool value =
-      detail::is_tuple_formattable_<T, C>::value;
-};
-
-template <typename Tuple, typename Char>
-struct formatter<Tuple, Char,
-                 enable_if_t<fmt::is_tuple_like<Tuple>::value &&
-                             fmt::is_tuple_formattable<Tuple, Char>::value>> {
- private:
-  decltype(detail::tuple::get_formatters<Tuple, Char>(
-      detail::tuple_index_sequence<Tuple>())) formatters_;
-
-  basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
-  basic_string_view<Char> opening_bracket_ =
-      detail::string_literal<Char, '('>{};
-  basic_string_view<Char> closing_bracket_ =
-      detail::string_literal<Char, ')'>{};
-
- public:
-  FMT_CONSTEXPR formatter() {}
-
-  FMT_CONSTEXPR void set_separator(basic_string_view<Char> sep) {
-    separator_ = sep;
-  }
-
-  FMT_CONSTEXPR void set_brackets(basic_string_view<Char> open,
-                                  basic_string_view<Char> close) {
-    opening_bracket_ = open;
-    closing_bracket_ = close;
-  }
-
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    auto it = ctx.begin();
-    auto end = ctx.end();
-    if (it != end && detail::to_ascii(*it) == 'n') {
-      ++it;
-      set_brackets({}, {});
-      set_separator({});
-    }
-    if (it != end && *it != '}') report_error("invalid format specifier");
-    ctx.advance_to(it);
-    detail::for_each(formatters_, detail::parse_empty_specs<Char>{ctx});
-    return it;
-  }
-
-  template <typename FormatContext>
-  auto format(const Tuple& value, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    ctx.advance_to(detail::copy<Char>(opening_bracket_, ctx.out()));
-    detail::for_each2(
-        formatters_, value,
-        detail::format_tuple_element<FormatContext>{0, ctx, separator_});
-    return detail::copy<Char>(closing_bracket_, ctx.out());
-  }
-};
-
-template <typename T, typename Char> struct is_range {
-  static constexpr const bool value =
-      detail::is_range_<T>::value && !detail::has_to_string_view<T>::value;
-};
-
-namespace detail {
-
-template <typename Char, typename Element>
-using range_formatter_type = formatter<remove_cvref_t<Element>, Char>;
-
-template <typename R>
-using maybe_const_range =
-    conditional_t<has_const_begin_end<R>::value, const R, R>;
-
-template <typename R, typename Char>
-struct is_formattable_delayed
-    : is_formattable<uncvref_type<maybe_const_range<R>>, Char> {};
-}  // namespace detail
-
-template <typename...> struct conjunction : std::true_type {};
-template <typename P> struct conjunction<P> : P {};
-template <typename P1, typename... Pn>
-struct conjunction<P1, Pn...>
-    : conditional_t<bool(P1::value), conjunction<Pn...>, P1> {};
-
-template <typename T, typename Char, typename Enable = void>
-struct range_formatter;
-
-template <typename T, typename Char>
-struct range_formatter<
-    T, Char,
-    enable_if_t<conjunction<std::is_same<T, remove_cvref_t<T>>,
-                            is_formattable<T, Char>>::value>> {
- private:
-  detail::range_formatter_type<Char, T> underlying_;
-  basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
-  basic_string_view<Char> opening_bracket_ =
-      detail::string_literal<Char, '['>{};
-  basic_string_view<Char> closing_bracket_ =
-      detail::string_literal<Char, ']'>{};
-  bool is_debug = false;
-
-  template <typename Output, typename It, typename Sentinel, typename U = T,
-            FMT_ENABLE_IF(std::is_same<U, Char>::value)>
-  auto write_debug_string(Output& out, It it, Sentinel end) const -> Output {
-    auto buf = basic_memory_buffer<Char>();
-    for (; it != end; ++it) buf.push_back(*it);
-    auto specs = format_specs();
-    specs.set_type(presentation_type::debug);
-    return detail::write<Char>(
-        out, basic_string_view<Char>(buf.data(), buf.size()), specs);
-  }
-
-  template <typename Output, typename It, typename Sentinel, typename U = T,
-            FMT_ENABLE_IF(!std::is_same<U, Char>::value)>
-  auto write_debug_string(Output& out, It, Sentinel) const -> Output {
-    return out;
-  }
-
- public:
-  FMT_CONSTEXPR range_formatter() {}
-
-  FMT_CONSTEXPR auto underlying() -> detail::range_formatter_type<Char, T>& {
-    return underlying_;
-  }
-
-  FMT_CONSTEXPR void set_separator(basic_string_view<Char> sep) {
-    separator_ = sep;
-  }
-
-  FMT_CONSTEXPR void set_brackets(basic_string_view<Char> open,
-                                  basic_string_view<Char> close) {
-    opening_bracket_ = open;
-    closing_bracket_ = close;
-  }
-
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    auto it = ctx.begin();
-    auto end = ctx.end();
-    detail::maybe_set_debug_format(underlying_, true);
-    if (it == end) return underlying_.parse(ctx);
-
-    switch (detail::to_ascii(*it)) {
-    case 'n':
-      set_brackets({}, {});
-      ++it;
-      break;
-    case '?':
-      is_debug = true;
-      set_brackets({}, {});
-      ++it;
-      if (it == end || *it != 's') report_error("invalid format specifier");
-      FMT_FALLTHROUGH;
-    case 's':
-      if (!std::is_same<T, Char>::value)
-        report_error("invalid format specifier");
-      if (!is_debug) {
-        set_brackets(detail::string_literal<Char, '"'>{},
-                     detail::string_literal<Char, '"'>{});
-        set_separator({});
-        detail::maybe_set_debug_format(underlying_, false);
-      }
-      ++it;
-      return it;
-    }
-
-    if (it != end && *it != '}') {
-      if (*it != ':') report_error("invalid format specifier");
-      detail::maybe_set_debug_format(underlying_, false);
-      ++it;
-    }
-
-    ctx.advance_to(it);
-    return underlying_.parse(ctx);
-  }
-
-  template <typename R, typename FormatContext>
-  auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    auto it = detail::range_begin(range);
-    auto end = detail::range_end(range);
-    if (is_debug) return write_debug_string(out, std::move(it), end);
-
-    out = detail::copy<Char>(opening_bracket_, out);
-    int i = 0;
-    for (; it != end; ++it) {
-      if (i > 0) out = detail::copy<Char>(separator_, out);
-      ctx.advance_to(out);
-      auto&& item = *it;  // Need an lvalue
-      out = underlying_.format(item, ctx);
-      ++i;
-    }
-    out = detail::copy<Char>(closing_bracket_, out);
-    return out;
-  }
-};
-
-FMT_EXPORT
-template <typename T, typename Char, typename Enable = void>
-struct range_format_kind
-    : conditional_t<
-          is_range<T, Char>::value, detail::range_format_kind_<T>,
-          std::integral_constant<range_format, range_format::disabled>> {};
-
-template <typename R, typename Char>
-struct formatter<
-    R, Char,
-    enable_if_t<conjunction<
-        bool_constant<
-            range_format_kind<R, Char>::value != range_format::disabled &&
-            range_format_kind<R, Char>::value != range_format::map &&
-            range_format_kind<R, Char>::value != range_format::string &&
-            range_format_kind<R, Char>::value != range_format::debug_string>,
-        detail::is_formattable_delayed<R, Char>>::value>> {
- private:
-  using range_type = detail::maybe_const_range<R>;
-  range_formatter<detail::uncvref_type<range_type>, Char> range_formatter_;
-
- public:
-  using nonlocking = void;
-
-  FMT_CONSTEXPR formatter() {
-    if (detail::const_check(range_format_kind<R, Char>::value !=
-                            range_format::set))
-      return;
-    range_formatter_.set_brackets(detail::string_literal<Char, '{'>{},
-                                  detail::string_literal<Char, '}'>{});
-  }
-
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    return range_formatter_.parse(ctx);
-  }
-
-  template <typename FormatContext>
-  auto format(range_type& range, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return range_formatter_.format(range, ctx);
-  }
-};
-
-// A map formatter.
-template <typename R, typename Char>
-struct formatter<
-    R, Char,
-    enable_if_t<conjunction<
-        bool_constant<range_format_kind<R, Char>::value == range_format::map>,
-        detail::is_formattable_delayed<R, Char>>::value>> {
- private:
-  using map_type = detail::maybe_const_range<R>;
-  using element_type = detail::uncvref_type<map_type>;
-
-  decltype(detail::tuple::get_formatters<element_type, Char>(
-      detail::tuple_index_sequence<element_type>())) formatters_;
-  bool no_delimiters_ = false;
-
- public:
-  FMT_CONSTEXPR formatter() {}
-
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    auto it = ctx.begin();
-    auto end = ctx.end();
-    if (it != end) {
-      if (detail::to_ascii(*it) == 'n') {
-        no_delimiters_ = true;
-        ++it;
-      }
-      if (it != end && *it != '}') {
-        if (*it != ':') report_error("invalid format specifier");
-        ++it;
-      }
-      ctx.advance_to(it);
-    }
-    detail::for_each(formatters_, detail::parse_empty_specs<Char>{ctx});
-    return it;
-  }
-
-  template <typename FormatContext>
-  auto format(map_type& map, FormatContext& ctx) const -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    basic_string_view<Char> open = detail::string_literal<Char, '{'>{};
-    if (!no_delimiters_) out = detail::copy<Char>(open, out);
-    int i = 0;
-    basic_string_view<Char> sep = detail::string_literal<Char, ',', ' '>{};
-    for (auto&& value : map) {
-      if (i > 0) out = detail::copy<Char>(sep, out);
-      ctx.advance_to(out);
-      detail::for_each2(formatters_, value,
-                        detail::format_tuple_element<FormatContext>{
-                            0, ctx, detail::string_literal<Char, ':', ' '>{}});
-      ++i;
-    }
-    basic_string_view<Char> close = detail::string_literal<Char, '}'>{};
-    if (!no_delimiters_) out = detail::copy<Char>(close, out);
-    return out;
-  }
-};
-
-// A (debug_)string formatter.
-template <typename R, typename Char>
-struct formatter<
-    R, Char,
-    enable_if_t<range_format_kind<R, Char>::value == range_format::string ||
-                range_format_kind<R, Char>::value ==
-                    range_format::debug_string>> {
- private:
-  using range_type = detail::maybe_const_range<R>;
-  using string_type =
-      conditional_t<std::is_constructible<
-                        detail::std_string_view<Char>,
-                        decltype(detail::range_begin(std::declval<R>())),
-                        decltype(detail::range_end(std::declval<R>()))>::value,
-                    detail::std_string_view<Char>, std::basic_string<Char>>;
-
-  formatter<string_type, Char> underlying_;
-
- public:
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    return underlying_.parse(ctx);
-  }
-
-  template <typename FormatContext>
-  auto format(range_type& range, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    if (detail::const_check(range_format_kind<R, Char>::value ==
-                            range_format::debug_string))
-      *out++ = '"';
-    out = underlying_.format(
-        string_type{detail::range_begin(range), detail::range_end(range)}, ctx);
-    if (detail::const_check(range_format_kind<R, Char>::value ==
-                            range_format::debug_string))
-      *out++ = '"';
-    return out;
-  }
-};
-
-template <typename It, typename Sentinel, typename Char = char>
-struct join_view : detail::view {
-  It begin;
-  Sentinel end;
-  basic_string_view<Char> sep;
-
-  join_view(It b, Sentinel e, basic_string_view<Char> s)
-      : begin(std::move(b)), end(e), sep(s) {}
-};
-
-template <typename It, typename Sentinel, typename Char>
-struct formatter<join_view<It, Sentinel, Char>, Char> {
- private:
-  using value_type =
-#ifdef __cpp_lib_ranges
-      std::iter_value_t<It>;
-#else
-      typename std::iterator_traits<It>::value_type;
-#endif
-  formatter<remove_cvref_t<value_type>, Char> value_formatter_;
-
-  using view = conditional_t<std::is_copy_constructible<It>::value,
-                             const join_view<It, Sentinel, Char>,
-                             join_view<It, Sentinel, Char>>;
-
- public:
-  using nonlocking = void;
-
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    return value_formatter_.parse(ctx);
-  }
-
-  template <typename FormatContext>
-  auto format(view& value, FormatContext& ctx) const -> decltype(ctx.out()) {
-    using iter =
-        conditional_t<std::is_copy_constructible<view>::value, It, It&>;
-    iter it = value.begin;
-    auto out = ctx.out();
-    if (it == value.end) return out;
-    out = value_formatter_.format(*it, ctx);
-    ++it;
-    while (it != value.end) {
-      out = detail::copy<Char>(value.sep.begin(), value.sep.end(), out);
-      ctx.advance_to(out);
-      out = value_formatter_.format(*it, ctx);
-      ++it;
-    }
-    return out;
-  }
-};
-
-template <typename Char, typename Tuple> struct tuple_join_view : detail::view {
-  const Tuple& tuple;
-  basic_string_view<Char> sep;
-
-  tuple_join_view(const Tuple& t, basic_string_view<Char> s)
-      : tuple(t), sep{s} {}
-};
-
-// Define FMT_TUPLE_JOIN_SPECIFIERS to enable experimental format specifiers
-// support in tuple_join. It is disabled by default because of issues with
-// the dynamic width and precision.
-#ifndef FMT_TUPLE_JOIN_SPECIFIERS
-#  define FMT_TUPLE_JOIN_SPECIFIERS 0
-#endif
-
-template <typename Char, typename Tuple>
-struct formatter<tuple_join_view<Char, Tuple>, Char,
-                 enable_if_t<is_tuple_like<Tuple>::value>> {
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    return do_parse(ctx, std::tuple_size<Tuple>());
-  }
-
-  template <typename FormatContext>
-  auto format(const tuple_join_view<Char, Tuple>& value,
-              FormatContext& ctx) const -> typename FormatContext::iterator {
-    return do_format(value, ctx, std::tuple_size<Tuple>());
-  }
-
- private:
-  decltype(detail::tuple::get_formatters<Tuple, Char>(
-      detail::tuple_index_sequence<Tuple>())) formatters_;
-
-  FMT_CONSTEXPR auto do_parse(parse_context<Char>& ctx,
-                              std::integral_constant<size_t, 0>)
-      -> const Char* {
-    return ctx.begin();
-  }
-
-  template <size_t N>
-  FMT_CONSTEXPR auto do_parse(parse_context<Char>& ctx,
-                              std::integral_constant<size_t, N>)
-      -> const Char* {
-    auto end = ctx.begin();
-#if FMT_TUPLE_JOIN_SPECIFIERS
-    end = std::get<std::tuple_size<Tuple>::value - N>(formatters_).parse(ctx);
-    if (N > 1) {
-      auto end1 = do_parse(ctx, std::integral_constant<size_t, N - 1>());
-      if (end != end1)
-        report_error("incompatible format specs for tuple elements");
-    }
-#endif
-    return end;
-  }
-
-  template <typename FormatContext>
-  auto do_format(const tuple_join_view<Char, Tuple>&, FormatContext& ctx,
-                 std::integral_constant<size_t, 0>) const ->
-      typename FormatContext::iterator {
-    return ctx.out();
-  }
-
-  template <typename FormatContext, size_t N>
-  auto do_format(const tuple_join_view<Char, Tuple>& value, FormatContext& ctx,
-                 std::integral_constant<size_t, N>) const ->
-      typename FormatContext::iterator {
-    using std::get;
-    auto out =
-        std::get<std::tuple_size<Tuple>::value - N>(formatters_)
-            .format(get<std::tuple_size<Tuple>::value - N>(value.tuple), ctx);
-    if (N <= 1) return out;
-    out = detail::copy<Char>(value.sep, out);
-    ctx.advance_to(out);
-    return do_format(value, ctx, std::integral_constant<size_t, N - 1>());
-  }
-};
-
-namespace detail {
-// Check if T has an interface like a container adaptor (e.g. std::stack,
-// std::queue, std::priority_queue).
-template <typename T> class is_container_adaptor_like {
-  template <typename U> static auto check(U* p) -> typename U::container_type;
-  template <typename> static void check(...);
-
- public:
-  static constexpr const bool value =
-      !std::is_void<decltype(check<T>(nullptr))>::value;
-};
-
-template <typename Container> struct all {
-  const Container& c;
-  auto begin() const -> typename Container::const_iterator { return c.begin(); }
-  auto end() const -> typename Container::const_iterator { return c.end(); }
-};
-}  // namespace detail
-
-template <typename T, typename Char>
-struct formatter<
-    T, Char,
-    enable_if_t<conjunction<detail::is_container_adaptor_like<T>,
-                            bool_constant<range_format_kind<T, Char>::value ==
-                                          range_format::disabled>>::value>>
-    : formatter<detail::all<typename T::container_type>, Char> {
-  using all = detail::all<typename T::container_type>;
-  template <typename FormatContext>
-  auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) {
-    struct getter : T {
-      static auto get(const T& v) -> all {
-        return {v.*(&getter::c)};  // Access c through the derived class.
-      }
-    };
-    return formatter<all>::format(getter::get(value), ctx);
-  }
-};
-
-FMT_BEGIN_EXPORT
-
-/// Returns a view that formats the iterator range `[begin, end)` with elements
-/// separated by `sep`.
-template <typename It, typename Sentinel>
-auto join(It begin, Sentinel end, string_view sep) -> join_view<It, Sentinel> {
-  return {std::move(begin), end, sep};
-}
-
-/**
- * Returns a view that formats `range` with elements separated by `sep`.
- *
- * **Example**:
- *
- *     auto v = std::vector<int>{1, 2, 3};
- *     fmt::print("{}", fmt::join(v, ", "));
- *     // Output: 1, 2, 3
- *
- * `fmt::join` applies passed format specifiers to the range elements:
- *
- *     fmt::print("{:02}", fmt::join(v, ", "));
- *     // Output: 01, 02, 03
- */
-template <typename Range, FMT_ENABLE_IF(!is_tuple_like<Range>::value)>
-auto join(Range&& r, string_view sep)
-    -> join_view<decltype(detail::range_begin(r)),
-                 decltype(detail::range_end(r))> {
-  return {detail::range_begin(r), detail::range_end(r), sep};
-}
-
-/**
- * Returns an object that formats `std::tuple` with elements separated by `sep`.
- *
- * **Example**:
- *
- *     auto t = std::tuple<int, char>{1, 'a'};
- *     fmt::print("{}", fmt::join(t, ", "));
- *     // Output: 1, a
- */
-template <typename Tuple, FMT_ENABLE_IF(is_tuple_like<Tuple>::value)>
-FMT_CONSTEXPR auto join(const Tuple& tuple, string_view sep)
-    -> tuple_join_view<char, Tuple> {
-  return {tuple, sep};
-}
-
-/**
- * Returns an object that formats `std::initializer_list` with elements
- * separated by `sep`.
- *
- * **Example**:
- *
- *     fmt::print("{}", fmt::join({1, 2, 3}, ", "));
- *     // Output: "1, 2, 3"
- */
-template <typename T>
-auto join(std::initializer_list<T> list, string_view sep)
-    -> join_view<const T*, const T*> {
-  return join(std::begin(list), std::end(list), sep);
-}
-
-FMT_END_EXPORT
-FMT_END_NAMESPACE
-
-#endif  // FMT_RANGES_H_
@@ -1,728 +0,0 @@
-// Formatting library for C++ - formatters for standard library types
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_STD_H_
-#define FMT_STD_H_
-
-#include "format.h"
-#include "ostream.h"
-
-#ifndef FMT_MODULE
-#  include <atomic>
-#  include <bitset>
-#  include <complex>
-#  include <cstdlib>
-#  include <exception>
-#  include <functional>
-#  include <memory>
-#  include <thread>
-#  include <type_traits>
-#  include <typeinfo>
-#  include <utility>
-#  include <vector>
-
-// Check FMT_CPLUSPLUS to suppress a bogus warning in MSVC.
-#  if FMT_CPLUSPLUS >= 201703L
-#    if FMT_HAS_INCLUDE(<filesystem>) && \
-        (!defined(FMT_CPP_LIB_FILESYSTEM) || FMT_CPP_LIB_FILESYSTEM != 0)
-#      include <filesystem>
-#    endif
-#    if FMT_HAS_INCLUDE(<variant>)
-#      include <variant>
-#    endif
-#    if FMT_HAS_INCLUDE(<optional>)
-#      include <optional>
-#    endif
-#  endif
-// Use > instead of >= in the version check because <source_location> may be
-// available after C++17 but before C++20 is marked as implemented.
-#  if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<source_location>)
-#    include <source_location>
-#  endif
-#  if FMT_CPLUSPLUS > 202002L && FMT_HAS_INCLUDE(<expected>)
-#    include <expected>
-#  endif
-#endif  // FMT_MODULE
-
-#if FMT_HAS_INCLUDE(<version>)
-#  include <version>
-#endif
-
-// GCC 4 does not support FMT_HAS_INCLUDE.
-#if FMT_HAS_INCLUDE(<cxxabi.h>) || defined(__GLIBCXX__)
-#  include <cxxabi.h>
-// Android NDK with gabi++ library on some architectures does not implement
-// abi::__cxa_demangle().
-#  ifndef __GABIXX_CXXABI_H__
-#    define FMT_HAS_ABI_CXA_DEMANGLE
-#  endif
-#endif
-
-// For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined.
-#ifndef FMT_CPP_LIB_FILESYSTEM
-#  ifdef __cpp_lib_filesystem
-#    define FMT_CPP_LIB_FILESYSTEM __cpp_lib_filesystem
-#  else
-#    define FMT_CPP_LIB_FILESYSTEM 0
-#  endif
-#endif
-
-#ifndef FMT_CPP_LIB_VARIANT
-#  ifdef __cpp_lib_variant
-#    define FMT_CPP_LIB_VARIANT __cpp_lib_variant
-#  else
-#    define FMT_CPP_LIB_VARIANT 0
-#  endif
-#endif
-
-#if FMT_CPP_LIB_FILESYSTEM
-FMT_BEGIN_NAMESPACE
-
-namespace detail {
-
-template <typename Char, typename PathChar>
-auto get_path_string(const std::filesystem::path& p,
-                     const std::basic_string<PathChar>& native) {
-  if constexpr (std::is_same_v<Char, char> && std::is_same_v<PathChar, wchar_t>)
-    return to_utf8<wchar_t>(native, to_utf8_error_policy::replace);
-  else
-    return p.string<Char>();
-}
-
-template <typename Char, typename PathChar>
-void write_escaped_path(basic_memory_buffer<Char>& quoted,
-                        const std::filesystem::path& p,
-                        const std::basic_string<PathChar>& native) {
-  if constexpr (std::is_same_v<Char, char> &&
-                std::is_same_v<PathChar, wchar_t>) {
-    auto buf = basic_memory_buffer<wchar_t>();
-    write_escaped_string<wchar_t>(std::back_inserter(buf), native);
-    bool valid = to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()});
-    FMT_ASSERT(valid, "invalid utf16");
-  } else if constexpr (std::is_same_v<Char, PathChar>) {
-    write_escaped_string<std::filesystem::path::value_type>(
-        std::back_inserter(quoted), native);
-  } else {
-    write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
-  }
-}
-
-}  // namespace detail
-
-template <typename Char> struct formatter<std::filesystem::path, Char> {
- private:
-  format_specs specs_;
-  detail::arg_ref<Char> width_ref_;
-  bool debug_ = false;
-  char path_type_ = 0;
-
- public:
-  FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; }
-
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) {
-    auto it = ctx.begin(), end = ctx.end();
-    if (it == end) return it;
-
-    it = detail::parse_align(it, end, specs_);
-    if (it == end) return it;
-
-    Char c = *it;
-    if ((c >= '0' && c <= '9') || c == '{')
-      it = detail::parse_width(it, end, specs_, width_ref_, ctx);
-    if (it != end && *it == '?') {
-      debug_ = true;
-      ++it;
-    }
-    if (it != end && (*it == 'g')) path_type_ = detail::to_ascii(*it++);
-    return it;
-  }
-
-  template <typename FormatContext>
-  auto format(const std::filesystem::path& p, FormatContext& ctx) const {
-    auto specs = specs_;
-    auto path_string =
-        !path_type_ ? p.native()
-                    : p.generic_string<std::filesystem::path::value_type>();
-
-    detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_,
-                                ctx);
-    if (!debug_) {
-      auto s = detail::get_path_string<Char>(p, path_string);
-      return detail::write(ctx.out(), basic_string_view<Char>(s), specs);
-    }
-    auto quoted = basic_memory_buffer<Char>();
-    detail::write_escaped_path(quoted, p, path_string);
-    return detail::write(ctx.out(),
-                         basic_string_view<Char>(quoted.data(), quoted.size()),
-                         specs);
-  }
-};
-
-class path : public std::filesystem::path {
- public:
-  auto display_string() const -> std::string {
-    const std::filesystem::path& base = *this;
-    return fmt::format(FMT_STRING("{}"), base);
-  }
-  auto system_string() const -> std::string { return string(); }
-
-  auto generic_display_string() const -> std::string {
-    const std::filesystem::path& base = *this;
-    return fmt::format(FMT_STRING("{:g}"), base);
-  }
-  auto generic_system_string() const -> std::string { return generic_string(); }
-};
-
-FMT_END_NAMESPACE
-#endif  // FMT_CPP_LIB_FILESYSTEM
-
-FMT_BEGIN_NAMESPACE
-template <std::size_t N, typename Char>
-struct formatter<std::bitset<N>, Char>
-    : nested_formatter<basic_string_view<Char>, Char> {
- private:
-  // Functor because C++11 doesn't support generic lambdas.
-  struct writer {
-    const std::bitset<N>& bs;
-
-    template <typename OutputIt>
-    FMT_CONSTEXPR auto operator()(OutputIt out) -> OutputIt {
-      for (auto pos = N; pos > 0; --pos) {
-        out = detail::write<Char>(out, bs[pos - 1] ? Char('1') : Char('0'));
-      }
-
-      return out;
-    }
-  };
-
- public:
-  template <typename FormatContext>
-  auto format(const std::bitset<N>& bs, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return this->write_padded(ctx, writer{bs});
-  }
-};
-
-template <typename Char>
-struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {};
-FMT_END_NAMESPACE
-
-#ifdef __cpp_lib_optional
-FMT_BEGIN_NAMESPACE
-template <typename T, typename Char>
-struct formatter<std::optional<T>, Char,
-                 std::enable_if_t<is_formattable<T, Char>::value>> {
- private:
-  formatter<T, Char> underlying_;
-  static constexpr basic_string_view<Char> optional =
-      detail::string_literal<Char, 'o', 'p', 't', 'i', 'o', 'n', 'a', 'l',
-                             '('>{};
-  static constexpr basic_string_view<Char> none =
-      detail::string_literal<Char, 'n', 'o', 'n', 'e'>{};
-
-  template <class U>
-  FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, bool set)
-      -> decltype(u.set_debug_format(set)) {
-    u.set_debug_format(set);
-  }
-
-  template <class U>
-  FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {}
-
- public:
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) {
-    maybe_set_debug_format(underlying_, true);
-    return underlying_.parse(ctx);
-  }
-
-  template <typename FormatContext>
-  auto format(const std::optional<T>& opt, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    if (!opt) return detail::write<Char>(ctx.out(), none);
-
-    auto out = ctx.out();
-    out = detail::write<Char>(out, optional);
-    ctx.advance_to(out);
-    out = underlying_.format(*opt, ctx);
-    return detail::write(out, ')');
-  }
-};
-FMT_END_NAMESPACE
-#endif  // __cpp_lib_optional
-
-#if defined(__cpp_lib_expected) || FMT_CPP_LIB_VARIANT
-
-FMT_BEGIN_NAMESPACE
-namespace detail {
-
-template <typename Char, typename OutputIt, typename T>
-auto write_escaped_alternative(OutputIt out, const T& v) -> OutputIt {
-  if constexpr (has_to_string_view<T>::value)
-    return write_escaped_string<Char>(out, detail::to_string_view(v));
-  if constexpr (std::is_same_v<T, Char>) return write_escaped_char(out, v);
-  return write<Char>(out, v);
-}
-
-}  // namespace detail
-
-FMT_END_NAMESPACE
-#endif
-
-#ifdef __cpp_lib_expected
-FMT_BEGIN_NAMESPACE
-
-template <typename T, typename E, typename Char>
-struct formatter<std::expected<T, E>, Char,
-                 std::enable_if_t<(std::is_void<T>::value ||
-                                   is_formattable<T, Char>::value) &&
-                                  is_formattable<E, Char>::value>> {
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext>
-  auto format(const std::expected<T, E>& value, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto out = ctx.out();
-
-    if (value.has_value()) {
-      out = detail::write<Char>(out, "expected(");
-      if constexpr (!std::is_void<T>::value)
-        out = detail::write_escaped_alternative<Char>(out, *value);
-    } else {
-      out = detail::write<Char>(out, "unexpected(");
-      out = detail::write_escaped_alternative<Char>(out, value.error());
-    }
-    *out++ = ')';
-    return out;
-  }
-};
-FMT_END_NAMESPACE
-#endif  // __cpp_lib_expected
-
-#ifdef __cpp_lib_source_location
-FMT_BEGIN_NAMESPACE
-template <> struct formatter<std::source_location> {
-  FMT_CONSTEXPR auto parse(parse_context<>& ctx) { return ctx.begin(); }
-
-  template <typename FormatContext>
-  auto format(const std::source_location& loc, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto out = ctx.out();
-    out = detail::write(out, loc.file_name());
-    out = detail::write(out, ':');
-    out = detail::write<char>(out, loc.line());
-    out = detail::write(out, ':');
-    out = detail::write<char>(out, loc.column());
-    out = detail::write(out, ": ");
-    out = detail::write(out, loc.function_name());
-    return out;
-  }
-};
-FMT_END_NAMESPACE
-#endif
-
-#if FMT_CPP_LIB_VARIANT
-FMT_BEGIN_NAMESPACE
-namespace detail {
-
-template <typename T>
-using variant_index_sequence =
-    std::make_index_sequence<std::variant_size<T>::value>;
-
-template <typename> struct is_variant_like_ : std::false_type {};
-template <typename... Types>
-struct is_variant_like_<std::variant<Types...>> : std::true_type {};
-
-// formattable element check.
-template <typename T, typename C> class is_variant_formattable_ {
-  template <std::size_t... Is>
-  static std::conjunction<
-      is_formattable<std::variant_alternative_t<Is, T>, C>...>
-      check(std::index_sequence<Is...>);
-
- public:
-  static constexpr const bool value =
-      decltype(check(variant_index_sequence<T>{}))::value;
-};
-
-}  // namespace detail
-
-template <typename T> struct is_variant_like {
-  static constexpr const bool value = detail::is_variant_like_<T>::value;
-};
-
-template <typename T, typename C> struct is_variant_formattable {
-  static constexpr const bool value =
-      detail::is_variant_formattable_<T, C>::value;
-};
-
-template <typename Char> struct formatter<std::monostate, Char> {
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext>
-  auto format(const std::monostate&, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return detail::write<Char>(ctx.out(), "monostate");
-  }
-};
-
-template <typename Variant, typename Char>
-struct formatter<
-    Variant, Char,
-    std::enable_if_t<std::conjunction_v<
-        is_variant_like<Variant>, is_variant_formattable<Variant, Char>>>> {
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    return ctx.begin();
-  }
-
-  template <typename FormatContext>
-  auto format(const Variant& value, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto out = ctx.out();
-
-    out = detail::write<Char>(out, "variant(");
-    FMT_TRY {
-      std::visit(
-          [&](const auto& v) {
-            out = detail::write_escaped_alternative<Char>(out, v);
-          },
-          value);
-    }
-    FMT_CATCH(const std::bad_variant_access&) {
-      detail::write<Char>(out, "valueless by exception");
-    }
-    *out++ = ')';
-    return out;
-  }
-};
-FMT_END_NAMESPACE
-#endif  // FMT_CPP_LIB_VARIANT
-
-FMT_BEGIN_NAMESPACE
-template <> struct formatter<std::error_code> {
- private:
-  format_specs specs_;
-  detail::arg_ref<char> width_ref_;
-  bool debug_ = false;
-
- public:
-  FMT_CONSTEXPR auto parse(parse_context<>& ctx) -> const char* {
-    auto it = ctx.begin(), end = ctx.end();
-    if (it == end) return it;
-
-    it = detail::parse_align(it, end, specs_);
-
-    char c = *it;
-    if (it != end && ((c >= '0' && c <= '9') || c == '{'))
-      it = detail::parse_width(it, end, specs_, width_ref_, ctx);
-
-    if (it != end && *it == '?') {
-      debug_ = true;
-      ++it;
-    }
-    if (it != end && *it == 's') {
-      specs_.set_type(presentation_type::string);
-      ++it;
-    }
-    return it;
-  }
-
-  template <typename FormatContext>
-  FMT_CONSTEXPR20 auto format(const std::error_code& ec,
-                              FormatContext& ctx) const -> decltype(ctx.out()) {
-    auto specs = specs_;
-    detail::handle_dynamic_spec(specs.dynamic_width(), specs.width, width_ref_,
-                                ctx);
-    auto buf = memory_buffer();
-    if (specs_.type() == presentation_type::string) {
-      buf.append(ec.message());
-    } else {
-      buf.append(string_view(ec.category().name()));
-      buf.push_back(':');
-      detail::write<char>(appender(buf), ec.value());
-    }
-    auto quoted = memory_buffer();
-    auto str = string_view(buf.data(), buf.size());
-    if (debug_) {
-      detail::write_escaped_string<char>(std::back_inserter(quoted), str);
-      str = string_view(quoted.data(), quoted.size());
-    }
-    return detail::write<char>(ctx.out(), str, specs);
-  }
-};
-
-#if FMT_USE_RTTI
-namespace detail {
-
-template <typename Char, typename OutputIt>
-auto write_demangled_name(OutputIt out, const std::type_info& ti) -> OutputIt {
-#  ifdef FMT_HAS_ABI_CXA_DEMANGLE
-  int status = 0;
-  std::size_t size = 0;
-  std::unique_ptr<char, void (*)(void*)> demangled_name_ptr(
-      abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);
-
-  string_view demangled_name_view;
-  if (demangled_name_ptr) {
-    demangled_name_view = demangled_name_ptr.get();
-
-    // Normalization of stdlib inline namespace names.
-    // libc++ inline namespaces.
-    //  std::__1::*       -> std::*
-    //  std::__1::__fs::* -> std::*
-    // libstdc++ inline namespaces.
-    //  std::__cxx11::*             -> std::*
-    //  std::filesystem::__cxx11::* -> std::filesystem::*
-    if (demangled_name_view.starts_with("std::")) {
-      char* begin = demangled_name_ptr.get();
-      char* to = begin + 5;  // std::
-      for (char *from = to, *end = begin + demangled_name_view.size();
-           from < end;) {
-        // This is safe, because demangled_name is NUL-terminated.
-        if (from[0] == '_' && from[1] == '_') {
-          char* next = from + 1;
-          while (next < end && *next != ':') next++;
-          if (next[0] == ':' && next[1] == ':') {
-            from = next + 2;
-            continue;
-          }
-        }
-        *to++ = *from++;
-      }
-      demangled_name_view = {begin, detail::to_unsigned(to - begin)};
-    }
-  } else {
-    demangled_name_view = string_view(ti.name());
-  }
-  return detail::write_bytes<Char>(out, demangled_name_view);
-#  elif FMT_MSC_VERSION
-  const string_view demangled_name(ti.name());
-  for (std::size_t i = 0; i < demangled_name.size(); ++i) {
-    auto sub = demangled_name;
-    sub.remove_prefix(i);
-    if (sub.starts_with("enum ")) {
-      i += 4;
-      continue;
-    }
-    if (sub.starts_with("class ") || sub.starts_with("union ")) {
-      i += 5;
-      continue;
-    }
-    if (sub.starts_with("struct ")) {
-      i += 6;
-      continue;
-    }
-    if (*sub.begin() != ' ') *out++ = *sub.begin();
-  }
-  return out;
-#  else
-  return detail::write_bytes<Char>(out, string_view(ti.name()));
-#  endif
-}
-
-}  // namespace detail
-
-template <typename Char>
-struct formatter<std::type_info, Char  // DEPRECATED! Mixing code unit types.
-                 > {
- public:
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    return ctx.begin();
-  }
-
-  template <typename Context>
-  auto format(const std::type_info& ti, Context& ctx) const
-      -> decltype(ctx.out()) {
-    return detail::write_demangled_name<Char>(ctx.out(), ti);
-  }
-};
-#endif
-
-template <typename T, typename Char>
-struct formatter<
-    T, Char,  // DEPRECATED! Mixing code unit types.
-    typename std::enable_if<std::is_base_of<std::exception, T>::value>::type> {
- private:
-  bool with_typename_ = false;
-
- public:
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    auto it = ctx.begin();
-    auto end = ctx.end();
-    if (it == end || *it == '}') return it;
-    if (*it == 't') {
-      ++it;
-      with_typename_ = FMT_USE_RTTI != 0;
-    }
-    return it;
-  }
-
-  template <typename Context>
-  auto format(const std::exception& ex, Context& ctx) const
-      -> decltype(ctx.out()) {
-    auto out = ctx.out();
-#if FMT_USE_RTTI
-    if (with_typename_) {
-      out = detail::write_demangled_name<Char>(out, typeid(ex));
-      *out++ = ':';
-      *out++ = ' ';
-    }
-#endif
-    return detail::write_bytes<Char>(out, string_view(ex.what()));
-  }
-};
-
-namespace detail {
-
-template <typename T, typename Enable = void>
-struct has_flip : std::false_type {};
-
-template <typename T>
-struct has_flip<T, void_t<decltype(std::declval<T>().flip())>>
-    : std::true_type {};
-
-template <typename T> struct is_bit_reference_like {
-  static constexpr const bool value =
-      std::is_convertible<T, bool>::value &&
-      std::is_nothrow_assignable<T, bool>::value && has_flip<T>::value;
-};
-
-#ifdef _LIBCPP_VERSION
-
-// Workaround for libc++ incompatibility with C++ standard.
-// According to the Standard, `bitset::operator[] const` returns bool.
-template <typename C>
-struct is_bit_reference_like<std::__bit_const_reference<C>> {
-  static constexpr const bool value = true;
-};
-
-#endif
-
-}  // namespace detail
-
-// We can't use std::vector<bool, Allocator>::reference and
-// std::bitset<N>::reference because the compiler can't deduce Allocator and N
-// in partial specialization.
-template <typename BitRef, typename Char>
-struct formatter<BitRef, Char,
-                 enable_if_t<detail::is_bit_reference_like<BitRef>::value>>
-    : formatter<bool, Char> {
-  template <typename FormatContext>
-  FMT_CONSTEXPR auto format(const BitRef& v, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return formatter<bool, Char>::format(v, ctx);
-  }
-};
-
-template <typename T, typename Deleter>
-auto ptr(const std::unique_ptr<T, Deleter>& p) -> const void* {
-  return p.get();
-}
-template <typename T> auto ptr(const std::shared_ptr<T>& p) -> const void* {
-  return p.get();
-}
-
-template <typename T, typename Char>
-struct formatter<std::atomic<T>, Char,
-                 enable_if_t<is_formattable<T, Char>::value>>
-    : formatter<T, Char> {
-  template <typename FormatContext>
-  auto format(const std::atomic<T>& v, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return formatter<T, Char>::format(v.load(), ctx);
-  }
-};
-
-#ifdef __cpp_lib_atomic_flag_test
-template <typename Char>
-struct formatter<std::atomic_flag, Char> : formatter<bool, Char> {
-  template <typename FormatContext>
-  auto format(const std::atomic_flag& v, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return formatter<bool, Char>::format(v.test(), ctx);
-  }
-};
-#endif  // __cpp_lib_atomic_flag_test
-
-template <typename T, typename Char> struct formatter<std::complex<T>, Char> {
- private:
-  detail::dynamic_format_specs<Char> specs_;
-
-  template <typename FormatContext, typename OutputIt>
-  FMT_CONSTEXPR auto do_format(const std::complex<T>& c,
-                               detail::dynamic_format_specs<Char>& specs,
-                               FormatContext& ctx, OutputIt out) const
-      -> OutputIt {
-    if (c.real() != 0) {
-      *out++ = Char('(');
-      out = detail::write<Char>(out, c.real(), specs, ctx.locale());
-      specs.set_sign(sign::plus);
-      out = detail::write<Char>(out, c.imag(), specs, ctx.locale());
-      if (!detail::isfinite(c.imag())) *out++ = Char(' ');
-      *out++ = Char('i');
-      *out++ = Char(')');
-      return out;
-    }
-    out = detail::write<Char>(out, c.imag(), specs, ctx.locale());
-    if (!detail::isfinite(c.imag())) *out++ = Char(' ');
-    *out++ = Char('i');
-    return out;
-  }
-
- public:
-  FMT_CONSTEXPR auto parse(parse_context<Char>& ctx) -> const Char* {
-    if (ctx.begin() == ctx.end() || *ctx.begin() == '}') return ctx.begin();
-    return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,
-                              detail::type_constant<T, Char>::value);
-  }
-
-  template <typename FormatContext>
-  auto format(const std::complex<T>& c, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    auto specs = specs_;
-    if (specs.dynamic()) {
-      detail::handle_dynamic_spec(specs.dynamic_width(), specs.width,
-                                  specs.width_ref, ctx);
-      detail::handle_dynamic_spec(specs.dynamic_precision(), specs.precision,
-                                  specs.precision_ref, ctx);
-    }
-
-    if (specs.width == 0) return do_format(c, specs, ctx, ctx.out());
-    auto buf = basic_memory_buffer<Char>();
-
-    auto outer_specs = format_specs();
-    outer_specs.width = specs.width;
-    outer_specs.copy_fill_from(specs);
-    outer_specs.set_align(specs.align());
-
-    specs.width = 0;
-    specs.set_fill({});
-    specs.set_align(align::none);
-
-    do_format(c, specs, ctx, basic_appender<Char>(buf));
-    return detail::write<Char>(ctx.out(),
-                               basic_string_view<Char>(buf.data(), buf.size()),
-                               outer_specs);
-  }
-};
-
-template <typename T, typename Char>
-struct formatter<std::reference_wrapper<T>, Char,
-                 enable_if_t<is_formattable<remove_cvref_t<T>, Char>::value>>
-    : formatter<remove_cvref_t<T>, Char> {
-  template <typename FormatContext>
-  auto format(std::reference_wrapper<T> ref, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
-    return formatter<remove_cvref_t<T>, Char>::format(ref.get(), ctx);
-  }
-};
-
-FMT_END_NAMESPACE
-#endif  // FMT_STD_H_
@@ -1,369 +0,0 @@
-// Formatting library for C++ - optional wchar_t and exotic character support
-//
-// Copyright (c) 2012 - present, Victor Zverovich
-// All rights reserved.
-//
-// For the license information refer to format.h.
-
-#ifndef FMT_XCHAR_H_
-#define FMT_XCHAR_H_
-
-#include "color.h"
-#include "format.h"
-#include "ostream.h"
-#include "ranges.h"
-
-#ifndef FMT_MODULE
-#  include <cwchar>
-#  if FMT_USE_LOCALE
-#    include <locale>
-#  endif
-#endif
-
-FMT_BEGIN_NAMESPACE
-namespace detail {
-
-template <typename T>
-using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;
-
-template <typename S, typename = void> struct format_string_char {};
-
-template <typename S>
-struct format_string_char<
-    S, void_t<decltype(sizeof(detail::to_string_view(std::declval<S>())))>> {
-  using type = char_t<S>;
-};
-
-template <typename S>
-struct format_string_char<
-    S, enable_if_t<std::is_base_of<detail::compile_string, S>::value>> {
-  using type = typename S::char_type;
-};
-
-template <typename S>
-using format_string_char_t = typename format_string_char<S>::type;
-
-inline auto write_loc(basic_appender<wchar_t> out, loc_value value,
-                      const format_specs& specs, locale_ref loc) -> bool {
-#if FMT_USE_LOCALE
-  auto& numpunct =
-      std::use_facet<std::numpunct<wchar_t>>(loc.get<std::locale>());
-  auto separator = std::wstring();
-  auto grouping = numpunct.grouping();
-  if (!grouping.empty()) separator = std::wstring(1, numpunct.thousands_sep());
-  return value.visit(loc_writer<wchar_t>{out, specs, separator, grouping, {}});
-#endif
-  return false;
-}
-}  // namespace detail
-
-FMT_BEGIN_EXPORT
-
-using wstring_view = basic_string_view<wchar_t>;
-using wformat_parse_context = parse_context<wchar_t>;
-using wformat_context = buffered_context<wchar_t>;
-using wformat_args = basic_format_args<wformat_context>;
-using wmemory_buffer = basic_memory_buffer<wchar_t>;
-
-template <typename Char, typename... T> struct basic_fstring {
- private:
-  basic_string_view<Char> str_;
-
-  static constexpr int num_static_named_args =
-      detail::count_static_named_args<T...>();
-
-  using checker = detail::format_string_checker<
-      Char, static_cast<int>(sizeof...(T)), num_static_named_args,
-      num_static_named_args != detail::count_named_args<T...>()>;
-
-  using arg_pack = detail::arg_pack<T...>;
-
- public:
-  using t = basic_fstring;
-
-  template <typename S,
-            FMT_ENABLE_IF(
-                std::is_convertible<const S&, basic_string_view<Char>>::value)>
-  FMT_CONSTEVAL FMT_ALWAYS_INLINE basic_fstring(const S& s) : str_(s) {
-    if (FMT_USE_CONSTEVAL)
-      detail::parse_format_string<Char>(s, checker(s, arg_pack()));
-  }
-  template <typename S,
-            FMT_ENABLE_IF(std::is_base_of<detail::compile_string, S>::value&&
-                              std::is_same<typename S::char_type, Char>::value)>
-  FMT_ALWAYS_INLINE basic_fstring(const S&) : str_(S()) {
-    FMT_CONSTEXPR auto sv = basic_string_view<Char>(S());
-    FMT_CONSTEXPR int ignore =
-        (parse_format_string(sv, checker(sv, arg_pack())), 0);
-    detail::ignore_unused(ignore);
-  }
-  basic_fstring(runtime_format_string<Char> fmt) : str_(fmt.str) {}
-
-  operator basic_string_view<Char>() const { return str_; }
-  auto get() const -> basic_string_view<Char> { return str_; }
-};
-
-template <typename Char, typename... T>
-using basic_format_string = basic_fstring<Char, T...>;
-
-template <typename... T>
-using wformat_string = typename basic_format_string<wchar_t, T...>::t;
-inline auto runtime(wstring_view s) -> runtime_format_string<wchar_t> {
-  return {{s}};
-}
-
-#ifdef __cpp_char8_t
-template <> struct is_char<char8_t> : bool_constant<detail::is_utf8_enabled> {};
-#endif
-
-template <typename... T>
-constexpr auto make_wformat_args(T&... args)
-    -> decltype(fmt::make_format_args<wformat_context>(args...)) {
-  return fmt::make_format_args<wformat_context>(args...);
-}
-
-#if !FMT_USE_NONTYPE_TEMPLATE_ARGS
-inline namespace literals {
-inline auto operator""_a(const wchar_t* s, size_t) -> detail::udl_arg<wchar_t> {
-  return {s};
-}
-}  // namespace literals
-#endif
-
-template <typename It, typename Sentinel>
-auto join(It begin, Sentinel end, wstring_view sep)
-    -> join_view<It, Sentinel, wchar_t> {
-  return {begin, end, sep};
-}
-
-template <typename Range, FMT_ENABLE_IF(!is_tuple_like<Range>::value)>
-auto join(Range&& range, wstring_view sep)
-    -> join_view<decltype(std::begin(range)), decltype(std::end(range)),
-                 wchar_t> {
-  return join(std::begin(range), std::end(range), sep);
-}
-
-template <typename T>
-auto join(std::initializer_list<T> list, wstring_view sep)
-    -> join_view<const T*, const T*, wchar_t> {
-  return join(std::begin(list), std::end(list), sep);
-}
-
-template <typename Tuple, FMT_ENABLE_IF(is_tuple_like<Tuple>::value)>
-auto join(const Tuple& tuple, basic_string_view<wchar_t> sep)
-    -> tuple_join_view<wchar_t, Tuple> {
-  return {tuple, sep};
-}
-
-template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
-auto vformat(basic_string_view<Char> fmt,
-             typename detail::vformat_args<Char>::type args)
-    -> std::basic_string<Char> {
-  auto buf = basic_memory_buffer<Char>();
-  detail::vformat_to(buf, fmt, args);
-  return {buf.data(), buf.size()};
-}
-
-template <typename... T>
-auto format(wformat_string<T...> fmt, T&&... args) -> std::wstring {
-  return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...));
-}
-
-template <typename OutputIt, typename... T>
-auto format_to(OutputIt out, wformat_string<T...> fmt, T&&... args)
-    -> OutputIt {
-  return vformat_to(out, fmt::wstring_view(fmt),
-                    fmt::make_wformat_args(args...));
-}
-
-// Pass char_t as a default template parameter instead of using
-// std::basic_string<char_t<S>> to reduce the symbol size.
-template <typename S, typename... T,
-          typename Char = detail::format_string_char_t<S>,
-          FMT_ENABLE_IF(!std::is_same<Char, char>::value &&
-                        !std::is_same<Char, wchar_t>::value)>
-auto format(const S& fmt, T&&... args) -> std::basic_string<Char> {
-  return vformat(detail::to_string_view(fmt),
-                 fmt::make_format_args<buffered_context<Char>>(args...));
-}
-
-template <typename Locale, typename S,
-          typename Char = detail::format_string_char_t<S>,
-          FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
-                            detail::is_exotic_char<Char>::value)>
-inline auto vformat(const Locale& loc, const S& fmt,
-                    typename detail::vformat_args<Char>::type args)
-    -> std::basic_string<Char> {
-  auto buf = basic_memory_buffer<Char>();
-  detail::vformat_to(buf, detail::to_string_view(fmt), args,
-                     detail::locale_ref(loc));
-  return {buf.data(), buf.size()};
-}
-
-template <typename Locale, typename S, typename... T,
-          typename Char = detail::format_string_char_t<S>,
-          FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
-                            detail::is_exotic_char<Char>::value)>
-inline auto format(const Locale& loc, const S& fmt, T&&... args)
-    -> std::basic_string<Char> {
-  return vformat(loc, detail::to_string_view(fmt),
-                 fmt::make_format_args<buffered_context<Char>>(args...));
-}
-
-template <typename OutputIt, typename S,
-          typename Char = detail::format_string_char_t<S>,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
-                            detail::is_exotic_char<Char>::value)>
-auto vformat_to(OutputIt out, const S& fmt,
-                typename detail::vformat_args<Char>::type args) -> OutputIt {
-  auto&& buf = detail::get_buffer<Char>(out);
-  detail::vformat_to(buf, detail::to_string_view(fmt), args);
-  return detail::get_iterator(buf, out);
-}
-
-template <typename OutputIt, typename S, typename... T,
-          typename Char = detail::format_string_char_t<S>,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value &&
-                        !std::is_same<Char, char>::value &&
-                        !std::is_same<Char, wchar_t>::value)>
-inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt {
-  return vformat_to(out, detail::to_string_view(fmt),
-                    fmt::make_format_args<buffered_context<Char>>(args...));
-}
-
-template <typename Locale, typename S, typename OutputIt, typename... Args,
-          typename Char = detail::format_string_char_t<S>,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
-                            detail::is_locale<Locale>::value&&
-                                detail::is_exotic_char<Char>::value)>
-inline auto vformat_to(OutputIt out, const Locale& loc, const S& fmt,
-                       typename detail::vformat_args<Char>::type args)
-    -> OutputIt {
-  auto&& buf = detail::get_buffer<Char>(out);
-  vformat_to(buf, detail::to_string_view(fmt), args, detail::locale_ref(loc));
-  return detail::get_iterator(buf, out);
-}
-
-template <typename Locale, typename OutputIt, typename S, typename... T,
-          typename Char = detail::format_string_char_t<S>,
-          bool enable = detail::is_output_iterator<OutputIt, Char>::value &&
-                        detail::is_locale<Locale>::value &&
-                        detail::is_exotic_char<Char>::value>
-inline auto format_to(OutputIt out, const Locale& loc, const S& fmt,
-                      T&&... args) ->
-    typename std::enable_if<enable, OutputIt>::type {
-  return vformat_to(out, loc, detail::to_string_view(fmt),
-                    fmt::make_format_args<buffered_context<Char>>(args...));
-}
-
-template <typename OutputIt, typename Char, typename... Args,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
-                            detail::is_exotic_char<Char>::value)>
-inline auto vformat_to_n(OutputIt out, size_t n, basic_string_view<Char> fmt,
-                         typename detail::vformat_args<Char>::type args)
-    -> format_to_n_result<OutputIt> {
-  using traits = detail::fixed_buffer_traits;
-  auto buf = detail::iterator_buffer<OutputIt, Char, traits>(out, n);
-  detail::vformat_to(buf, fmt, args);
-  return {buf.out(), buf.count()};
-}
-
-template <typename OutputIt, typename S, typename... T,
-          typename Char = detail::format_string_char_t<S>,
-          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
-                            detail::is_exotic_char<Char>::value)>
-inline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... args)
-    -> format_to_n_result<OutputIt> {
-  return vformat_to_n(out, n, fmt::basic_string_view<Char>(fmt),
-                      fmt::make_format_args<buffered_context<Char>>(args...));
-}
-
-template <typename S, typename... T,
-          typename Char = detail::format_string_char_t<S>,
-          FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
-inline auto formatted_size(const S& fmt, T&&... args) -> size_t {
-  auto buf = detail::counting_buffer<Char>();
-  detail::vformat_to(buf, detail::to_string_view(fmt),
-                     fmt::make_format_args<buffered_context<Char>>(args...));
-  return buf.count();
-}
-
-inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) {
-  auto buf = wmemory_buffer();
-  detail::vformat_to(buf, fmt, args);
-  buf.push_back(L'\0');
-  if (std::fputws(buf.data(), f) == -1)
-    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
-}
-
-inline void vprint(wstring_view fmt, wformat_args args) {
-  vprint(stdout, fmt, args);
-}
-
-template <typename... T>
-void print(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
-  return vprint(f, wstring_view(fmt), fmt::make_wformat_args(args...));
-}
-
-template <typename... T> void print(wformat_string<T...> fmt, T&&... args) {
-  return vprint(wstring_view(fmt), fmt::make_wformat_args(args...));
-}
-
-template <typename... T>
-void println(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
-  return print(f, L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
-}
-
-template <typename... T> void println(wformat_string<T...> fmt, T&&... args) {
-  return print(L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
-}
-
-inline auto vformat(text_style ts, wstring_view fmt, wformat_args args)
-    -> std::wstring {
-  auto buf = wmemory_buffer();
-  detail::vformat_to(buf, ts, fmt, args);
-  return {buf.data(), buf.size()};
-}
-
-template <typename... T>
-inline auto format(text_style ts, wformat_string<T...> fmt, T&&... args)
-    -> std::wstring {
-  return fmt::vformat(ts, fmt, fmt::make_wformat_args(args...));
-}
-
-template <typename... T>
-FMT_DEPRECATED void print(std::FILE* f, text_style ts, wformat_string<T...> fmt,
-                          const T&... args) {
-  vprint(f, ts, fmt, fmt::make_wformat_args(args...));
-}
-
-template <typename... T>
-FMT_DEPRECATED void print(text_style ts, wformat_string<T...> fmt,
-                          const T&... args) {
-  return print(stdout, ts, fmt, args...);
-}
-
-inline void vprint(std::wostream& os, wstring_view fmt, wformat_args args) {
-  auto buffer = basic_memory_buffer<wchar_t>();
-  detail::vformat_to(buffer, fmt, args);
-  detail::write_buffer(os, buffer);
-}
-
-template <typename... T>
-void print(std::wostream& os, wformat_string<T...> fmt, T&&... args) {
-  vprint(os, fmt, fmt::make_format_args<buffered_context<wchar_t>>(args...));
-}
-
-template <typename... T>
-void println(std::wostream& os, wformat_string<T...> fmt, T&&... args) {
-  print(os, L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
-}
-
-/// Converts `value` to `std::wstring` using the default format for type `T`.
-template <typename T> inline auto to_wstring(const T& value) -> std::wstring {
-  return format(FMT_STRING(L"{}"), value);
-}
-FMT_END_EXPORT
-FMT_END_NAMESPACE
-
-#endif  // FMT_XCHAR_H_
@@ -9,9 +9,23 @@
 #ifndef _FUSE_H_
 #define _FUSE_H_

+/** @file
+ *
+ * This file defines the library interface of FUSE
+ *
+ * IMPORTANT: you should define FUSE_USE_VERSION before including this
+ * header.  To use the newest API define it to 26 (recommended for any
+ * new application), to use the old API define it to 21 (default) 22
+ * or 25, to use the even older 1.X API define it to 11.
+ */
+
+#ifndef FUSE_USE_VERSION
+#define FUSE_USE_VERSION 21
+#endif
+
 #include "extern_c.h"
 #include "fuse_common.h"
-#include "fuse_kernel.h"
+#include "fuse_dirents.h"

 #include <fcntl.h>
 #include <time.h>
@@ -20,7 +34,6 @@
 #include <sys/stat.h>
 #include <sys/statvfs.h>
 #include <sys/uio.h>
-#include <stdint.h>

 EXTERN_C_BEGIN

@@ -34,9 +47,6 @@ struct fuse;
 /** Structure containing a raw command */
 struct fuse_cmd;

-struct fuse_dirents_t;
-typedef struct fuse_dirents_t fuse_dirents_t;
-
 /**
 * The file system operations:
 *
@@ -95,6 +105,15 @@ struct fuse_operations
   * */
  int (*mkdir) (const char *, mode_t);

+  /** Hide files unlinked / renamed over
+   *
+   * Allows storing of a file handle when a file is unlinked
+   * while open. Helps manage the fact the kernel usually does
+   * not send fh with getattr requests.
+   */
+  int (*prepare_hide)(const char *name_, uint64_t *fh_);
+  int (*free_hide)(const uint64_t fh_);
+
  /** Remove a file */
  int (*unlink) (const char *);

@@ -102,25 +121,31 @@ struct fuse_operations
  int (*rmdir) (const char *);

  /** Create a symbolic link */
-  int (*symlink) (const char *, const char *, struct stat *, fuse_timeouts_t *);
+  int (*symlink) (const char *, const char *);

  /** Rename a file */
  int (*rename) (const char *, const char *);

  /** Create a hard link to a file */
-  int (*link) (const char *, const char *, struct stat *, fuse_timeouts_t *);
+  int (*link) (const char *, const char *);

  /** Change the permission bits of a file */
  int (*chmod) (const char *, mode_t);
-  int (*fchmod)(const uint64_t, const mode_t);
+  int (*fchmod)(const struct fuse_file_info *, const mode_t);

  /** Change the owner and group of a file */
  int (*chown) (const char *, uid_t, gid_t);
-  int (*fchown)(const uint64_t, const uid_t, const gid_t);
+  int (*fchown)(const struct fuse_file_info *, const uid_t, const gid_t);

  /** Change the size of a file */
  int (*truncate) (const char *, off_t);

+  /** Change the access and/or modification times of a file
+   *
+   * Deprecated, use utimens() instead.
+   */
+  int (*utime) (const char *, struct utimbuf *);
+
  /** File open operation
   *
   * No creation (O_CREAT, O_EXCL) and by default also no
@@ -138,7 +163,32 @@ struct fuse_operations
   *
   * Changed in version 2.2
   */
-  int (*open) (const char *, fuse_file_info_t *);
+  int (*open) (const char *, struct fuse_file_info *);
+
+  /** Read data from an open file
+   *
+   * Read should return exactly the number of bytes requested except
+   * on EOF or error, otherwise the rest of the data will be
+   * substituted with zeroes.	 An exception to this is when the
+   * 'direct_io' mount option is specified, in which case the return
+   * value of the read system call will reflect the return value of
+   * this operation.
+   *
+   * Changed in version 2.2
+   */
+  int (*read) (char *, size_t, off_t,
+               struct fuse_file_info *);
+
+  /** Write data to an open file
+   *
+   * Write should return exactly the number of bytes requested
+   * except on error.	 An exception to this is when the 'direct_io'
+   * mount option is specified (see read operation).
+   *
+   * Changed in version 2.2
+   */
+  int (*write) (const char *, size_t, off_t,
+                struct fuse_file_info *);

  /** Get file system statistics
   *
@@ -172,7 +222,7 @@ struct fuse_operations
   *
   * Changed in version 2.2
   */
-  int (*flush) (const fuse_file_info_t *);
+  int (*flush) (struct fuse_file_info *);

  /** Release an open file
   *
@@ -188,7 +238,7 @@ struct fuse_operations
   *
   * Changed in version 2.2
   */
-  int (*release) (const fuse_file_info_t *);
+  int (*release) (struct fuse_file_info *);

  /** Synchronize file contents
   *
@@ -197,7 +247,7 @@ struct fuse_operations
   *
   * Changed in version 2.2
   */
-  int (*fsync) (const uint64_t, int);
+  int (*fsync) (int, struct fuse_file_info *);

  /** Set extended attributes */
  int (*setxattr) (const char *, const char *, const char *, size_t, int);
@@ -221,8 +271,7 @@ struct fuse_operations
   *
   * Introduced in version 2.3
   */
-  int (*opendir) (const char *,
-                  fuse_file_info_t *);
+  int (*opendir) (const char *, struct fuse_file_info *);

  /** Read directory
   *
@@ -245,10 +294,10 @@ struct fuse_operations
   *
   * Introduced in version 2.3
   */
-  int (*readdir)(const fuse_file_info_t *,
+  int (*readdir)(struct fuse_file_info *,
                 fuse_dirents_t *);

-  int (*readdir_plus)(const fuse_file_info_t *,
+  int (*readdir_plus)(struct fuse_file_info *,
                      fuse_dirents_t *);


@@ -256,7 +305,7 @@ struct fuse_operations
   *
   * Introduced in version 2.3
   */
-  int (*releasedir) (const fuse_file_info_t *);
+  int (*releasedir) (struct fuse_file_info *);

  /** Synchronize directory contents
   *
@@ -265,7 +314,7 @@ struct fuse_operations
   *
   * Introduced in version 2.3
   */
-  int (*fsyncdir) (const fuse_file_info_t *, int);
+  int (*fsyncdir) (int, struct fuse_file_info *);

  /**
   * Initialize filesystem
@@ -286,7 +335,7 @@ struct fuse_operations
   *
   * Introduced in version 2.3
   */
-  void (*destroy) (void);
+  void (*destroy) (void *);

  /**
   * Check file access permissions
@@ -313,7 +362,7 @@ struct fuse_operations
   *
   * Introduced in version 2.5
   */
-  int (*create) (const char *, mode_t, fuse_file_info_t *);
+  int (*create) (const char *, mode_t, struct fuse_file_info *);

  /**
   * Change the size of an open file
@@ -327,7 +376,7 @@ struct fuse_operations
   *
   * Introduced in version 2.5
   */
-  int (*ftruncate) (const uint64_t, off_t);
+  int (*ftruncate) (off_t, struct fuse_file_info *);

  /**
   * Get attributes from an open file
@@ -341,7 +390,7 @@ struct fuse_operations
   *
   * Introduced in version 2.5
   */
-  int (*fgetattr) (const uint64_t, struct stat *, fuse_timeouts_t *);
+  int (*fgetattr) (struct stat *, struct fuse_file_info *, fuse_timeouts_t *);

  /**
   * Perform POSIX file locking operation
@@ -375,8 +424,7 @@ struct fuse_operations
   *
   * Introduced in version 2.6
   */
-  int (*lock) (const fuse_file_info_t *,
-               int cmd,
+  int (*lock) (struct fuse_file_info *, int cmd,
               struct flock *);

  /**
@@ -391,7 +439,7 @@ struct fuse_operations
   * Introduced in version 2.6
   */
  int (*utimens)(const char *, const struct timespec tv[2]);
-  int (*futimens)(const uint64_t fh, const struct timespec tv[2]);
+  int (*futimens)(const struct fuse_file_info *ffi_, const struct timespec tv_[2]);

  /**
   * Map block index within file to block index within device
@@ -418,12 +466,12 @@ struct fuse_operations
   *
   * Introduced in version 2.8
   */
-  int (*ioctl) (const fuse_file_info_t *ffi,
-                unsigned long           cmd,
-                void                   *arg,
-                unsigned int            flags,
-                void                   *data,
-                uint32_t               *out_bufsz);
+  int (*ioctl) (unsigned long cmd,
+                void *arg,
+                struct fuse_file_info *ffi,
+                unsigned int flags,
+                void *data,
+                uint32_t *out_bufsz);

  /**
   * Poll for IO readiness events
@@ -442,9 +490,8 @@ struct fuse_operations
   *
   * Introduced in version 2.8
   */
-  int (*poll) (const fuse_file_info_t *ffi,
-               fuse_pollhandle_t      *ph,
-               unsigned               *reventsp);
+  int (*poll) (struct fuse_file_info *,
+               struct fuse_pollhandle *ph, unsigned *reventsp);

  /** Write contents of buffer to an open file
   *
@@ -454,10 +501,8 @@ struct fuse_operations
   *
   * Introduced in version 2.9
   */
-  int (*write) (const fuse_file_info_t *ffi,
-                const char             *data,
-                size_t                  size,
-                off_t                   off);
+  int (*write_buf) (struct fuse_bufvec *buf, off_t off,
+                    struct fuse_file_info *);

  /** Store data from an open file in a buffer
   *
@@ -475,10 +520,8 @@ struct fuse_operations
   *
   * Introduced in version 2.9
   */
-  int (*read)(const fuse_file_info_t *ffi,
-              char                   *buf,
-              size_t                  size,
-              off_t                   off);
+  int (*read_buf) (struct fuse_bufvec **bufp,
+                   size_t size, off_t off, struct fuse_file_info *);
  /**
   * Perform BSD file locking operation
   *
@@ -499,7 +542,7 @@ struct fuse_operations
   *
   * Introduced in version 2.9
   */
-  int (*flock) (const fuse_file_info_t *, int op);
+  int (*flock) (struct fuse_file_info *, int op);

  /**
   * Allocates space for an open file
@@ -511,7 +554,7 @@ struct fuse_operations
   *
   * Introduced in version 2.9.1
   */
-  int (*fallocate) (const uint64_t, int, off_t, off_t);
+  int (*fallocate) (int, off_t, off_t,struct fuse_file_info *);

  /**
   * Copy a range of data from one file to another
@@ -526,32 +569,12 @@ struct fuse_operations
   * destination. Effectively doing an inefficient copy of the
   * data.
   */
-  ssize_t (*copy_file_range)(const fuse_file_info_t *fi_in,
-                             off_t                   offset_in,
-                             const fuse_file_info_t *fi_out,
-                             off_t                   offset_out,
-                             size_t                  size,
-                             int                     flags);
-
-  ssize_t (*setupmapping)(uint64_t *fh_,
-                          uint64_t  foffset_,
-                          uint64_t  len_,
-                          uint64_t  flags_,
-                          uint64_t  moffset_);
-
-  int (*removemapping)();
-  int (*syncfs)();
-  int (*tmpfile)(const char *, mode_t, fuse_file_info_t *);
-  int (*statx)(const char        *fusepath,
-               const uint32_t     flags,
-               const uint32_t     mask,
-               struct fuse_statx *st,
-               fuse_timeouts_t   *timeout);
-  int (*statx_fh)(const uint64_t     fh,
-                  const uint32_t     flags,
-                  const uint32_t     mask,
-                  struct fuse_statx *st,
-                  fuse_timeouts_t   *timeout);
+  ssize_t (*copy_file_range)(struct fuse_file_info *fi_in,
+                             off_t                  offset_in,
+                             struct fuse_file_info *fi_out,
+                             off_t                  offset_out,
+                             size_t                 size,
+                             int                    flags);
 };

 /** Extra context that may be needed by some filesystems
@@ -561,14 +584,23 @@ struct fuse_operations
 */
 struct fuse_context
 {
-  uint64_t unique;
-  uint64_t nodeid;
-  uint32_t opcode;
-  uid_t    uid;
-  gid_t    gid;
-  pid_t    pid;
-  mode_t   umask;
+  /** Pointer to the fuse object */
  struct fuse *fuse;
+
+  /** User ID of the calling process */
+  uid_t uid;
+
+  /** Group ID of the calling process */
+  gid_t gid;
+
+  /** Thread ID of the calling process */
+  pid_t pid;
+
+  /** Private filesystem data */
+  void *private_data;
+
+  /** Umask of the calling process (introduced in version 2.8) */
+  mode_t umask;
 };

 /**
@@ -591,13 +623,15 @@ struct fuse_context
 * @param argc the argument counter passed to the main() function
 * @param argv the argument vector passed to the main() function
 * @param op the file system operation
+ * @param user_data user data supplied in the context during the init() method
 * @return 0 on success, nonzero on failure
 */
 /*
-  int fuse_main(int argc, char *argv[], const struct fuse_operations *op);
+  int fuse_main(int argc, char *argv[], const struct fuse_operations *op,
+  void *user_data);
 */
-#define fuse_main(argc, argv, op)                    \
-  fuse_main_real(argc, argv, op, sizeof(*(op)))
+#define fuse_main(argc, argv, op, user_data)                    \
+  fuse_main_real(argc, argv, op, sizeof(*(op)), user_data)

 /* ----------------------------------------------------------- *
 * More detailed API					       *
@@ -610,10 +644,12 @@ struct fuse_context
 * @param args argument vector
 * @param op the filesystem operations
 * @param op_size the size of the fuse_operations structure
+ * @param user_data user data supplied in the context during the init() method
 * @return the created FUSE handle
 */
 struct fuse *fuse_new(struct fuse_chan *ch, struct fuse_args *args,
-                      const struct fuse_operations *op, size_t op_size);
+                      const struct fuse_operations *op, size_t op_size,
+                      void *user_data);

 /**
 * Destroy the FUSE handle.
@@ -634,10 +670,7 @@ void fuse_destroy(struct fuse *f);
 */
 void fuse_exit(struct fuse *f);

-int fuse_config_read_thread_count(const struct fuse *f);
-int fuse_config_process_thread_count(const struct fuse *f);
-int fuse_config_process_thread_queue_depth(const struct fuse *f);
-const char* fuse_config_pin_threads(const struct fuse *f);
+int fuse_config_num_threads(const struct fuse *fuse_);

 /**
 * FUSE event loop with multiple threads
@@ -686,13 +719,25 @@ int fuse_is_lib_option(const char *opt);
 *
 * Do not call this directly, use fuse_main()
 */
-int fuse_main_real(int argc, char *argv[], const struct fuse_operations *op, size_t op_size);
+int fuse_main_real(int argc, char *argv[], const struct fuse_operations *op,
+                   size_t op_size, void *user_data);

-void fuse_populate_maintenance_thread(struct fuse *fuse);
-
-int  fuse_log_metrics_get(void);
-void fuse_log_metrics_set(int enabled);
+/**
+ * Start the cleanup thread when using option "remember".
+ *
+ * This is done automatically by fuse_loop_mt()
+ * @param fuse struct fuse pointer for fuse instance
+ * @return 0 on success and -1 on error
+ */
+int fuse_start_cleanup_thread(struct fuse *fuse);

+/**
+ * Stop the cleanup thread when using option "remember".
+ *
+ * This is done automatically by fuse_loop_mt()
+ * @param fuse struct fuse pointer for fuse instance
+ */
+void fuse_stop_cleanup_thread(struct fuse *fuse);

 /**
 * Iterate over cache removing stale entries
@@ -725,7 +770,99 @@ struct fuse_fs;
 * fuse_fs_releasedir and fuse_fs_statfs, which return 0.
 */

-int fuse_notify_poll(fuse_pollhandle_t *ph);
+int fuse_fs_getattr(struct fuse_fs  *fs,
+                    const char      *path,
+                    struct stat     *buf,
+                    fuse_timeouts_t *timeout);
+
+int fuse_fs_fgetattr(struct fuse_fs        *fs,
+                     struct stat           *buf,
+                     struct fuse_file_info *fi,
+                     fuse_timeouts_t       *timeout);
+
+int fuse_fs_rename(struct fuse_fs *fs, const char *oldpath,
+                   const char *newpath);
+int fuse_fs_unlink(struct fuse_fs *fs, const char *path);
+int fuse_fs_rmdir(struct fuse_fs *fs, const char *path);
+int fuse_fs_symlink(struct fuse_fs *fs, const char *linkname,
+                    const char *path);
+int fuse_fs_link(struct fuse_fs *fs, const char *oldpath, const char *newpath);
+int fuse_fs_release(struct fuse_fs *fs,
+                    struct fuse_file_info *fi);
+int fuse_fs_open(struct fuse_fs *fs, const char *path,
+                 struct fuse_file_info *fi);
+int fuse_fs_read(struct fuse_fs *fs, char *buf, size_t size,
+                 off_t off, struct fuse_file_info *fi);
+int fuse_fs_read_buf(struct fuse_fs *fs,
+                     struct fuse_bufvec **bufp, size_t size, off_t off,
+                     struct fuse_file_info *fi);
+int fuse_fs_write(struct fuse_fs *fs, const char *buf,
+                  size_t size, off_t off, struct fuse_file_info *fi);
+int fuse_fs_write_buf(struct fuse_fs *fs,
+                      struct fuse_bufvec *buf, off_t off,
+                      struct fuse_file_info *fi);
+int fuse_fs_fsync(struct fuse_fs *fs, int datasync,
+                  struct fuse_file_info *fi);
+int fuse_fs_flush(struct fuse_fs *fs,
+                  struct fuse_file_info *fi);
+int fuse_fs_statfs(struct fuse_fs *fs, const char *path, struct statvfs *buf);
+int fuse_fs_opendir(struct fuse_fs *fs, const char *path,
+                    struct fuse_file_info *fi);
+int fuse_fs_readdir(struct fuse_fs        *fs,
+                    struct fuse_file_info *fi,
+                    fuse_dirents_t        *buf);
+int fuse_fs_fsyncdir(struct fuse_fs *fs, int datasync,
+                     struct fuse_file_info *fi);
+int fuse_fs_releasedir(struct fuse_fs *fs,
+                       struct fuse_file_info *fi);
+int fuse_fs_create(struct fuse_fs *fs, const char *path, mode_t mode,
+                   struct fuse_file_info *fi);
+int fuse_fs_lock(struct fuse_fs *fs,
+                 struct fuse_file_info *fi, int cmd, struct flock *lock);
+int fuse_fs_flock(struct fuse_fs *fs,
+                  struct fuse_file_info *fi, int op);
+int fuse_fs_chmod(struct fuse_fs *fs, const char *path, mode_t mode);
+int fuse_fs_chown(struct fuse_fs *fs, const char *path, uid_t uid, gid_t gid);
+int fuse_fs_truncate(struct fuse_fs *fs, const char *path, off_t size);
+int fuse_fs_ftruncate(struct fuse_fs *fs, off_t size,
+                      struct fuse_file_info *fi);
+int fuse_fs_utimens(struct fuse_fs *fs, const char *path,
+                    const struct timespec tv[2]);
+int fuse_fs_access(struct fuse_fs *fs, const char *path, int mask);
+int fuse_fs_readlink(struct fuse_fs *fs, const char *path, char *buf,
+                     size_t len);
+int fuse_fs_mknod(struct fuse_fs *fs, const char *path, mode_t mode,
+                  dev_t rdev);
+int fuse_fs_mkdir(struct fuse_fs *fs, const char *path, mode_t mode);
+int fuse_fs_setxattr(struct fuse_fs *fs, const char *path, const char *name,
+                     const char *value, size_t size, int flags);
+int fuse_fs_getxattr(struct fuse_fs *fs, const char *path, const char *name,
+                     char *value, size_t size);
+int fuse_fs_listxattr(struct fuse_fs *fs, const char *path, char *list,
+                      size_t size);
+int fuse_fs_removexattr(struct fuse_fs *fs, const char *path,
+                        const char *name);
+int fuse_fs_bmap(struct fuse_fs *fs, const char *path, size_t blocksize,
+                 uint64_t *idx);
+int fuse_fs_ioctl(struct fuse_fs *fs, unsigned long cmd, void *arg,
+                  struct fuse_file_info *fi, unsigned int flags,
+                  void *data, uint32_t *out_bufsz);
+int fuse_fs_poll(struct fuse_fs *fs,
+                 struct fuse_file_info *fi, struct fuse_pollhandle *ph,
+                 unsigned *reventsp);
+int fuse_fs_fallocate(struct fuse_fs *fs, int mode,
+                      off_t offset, off_t length, struct fuse_file_info *fi);
+void fuse_fs_init(struct fuse_fs *fs, struct fuse_conn_info *conn);
+void fuse_fs_destroy(struct fuse_fs *fs);
+
+int fuse_fs_prepare_hide(struct fuse_fs *fs, const char *path, uint64_t *fh);
+int fuse_fs_free_hide(struct fuse_fs *fs, uint64_t fh);
+ssize_t fuse_fs_copy_file_range(struct fuse_fs *fs,
+                                struct fuse_file_info *fi_in, off_t off_in,
+                                struct fuse_file_info *fi_out, off_t off_out,
+                                size_t len, int flags);
+
+int fuse_notify_poll(struct fuse_pollhandle *ph);

 /**
 * Create a new fuse filesystem object
@@ -735,9 +872,11 @@ int fuse_notify_poll(fuse_pollhandle_t *ph);
 *
 * @param op the filesystem operations
 * @param op_size the size of the fuse_operations structure
+ * @param user_data user data supplied in the context during the init() method
 * @return a new filesystem object
 */
-struct fuse_fs *fuse_fs_new(const struct fuse_operations *op, size_t op_size);
+struct fuse_fs *fuse_fs_new(const struct fuse_operations *op, size_t op_size,
+                            void *user_data);

 /* ----------------------------------------------------------- *
 * Advanced API for event handling, don't worry about this...  *
@@ -752,11 +891,18 @@ typedef void (*fuse_processor_t)(struct fuse *, struct fuse_cmd *, void *);
 /** This is the part of fuse_main() before the event loop */
 struct fuse *fuse_setup(int argc, char *argv[],
                        const struct fuse_operations *op, size_t op_size,
-                        char **mountpoint);
+                        char **mountpoint,
+                        void *user_data);

 /** This is the part of fuse_main() after the event loop */
 void fuse_teardown(struct fuse *fuse, char *mountpoint);

+/** Read a single command.  If none are read, return NULL */
+struct fuse_cmd *fuse_read_cmd(struct fuse *f);
+
+/** Process a single command */
+void fuse_process_cmd(struct fuse *f, struct fuse_cmd *cmd);
+
 /** Multi threaded event loop, which calls the custom command
    processor function */
 int fuse_loop_mt_proc(struct fuse *f, fuse_processor_t proc, void *data);
@@ -771,16 +917,6 @@ void fuse_set_getcontext_func(struct fuse_context *(*func)(void));
 /** Get session from fuse object */
 struct fuse_session *fuse_get_session(struct fuse *f);

-void fuse_gc1();
-void fuse_gc();
-void fuse_invalidate_all_nodes();
-
-int fuse_get_dev_fuse_fd(const struct fuse_context *fc);
-int fuse_passthrough_open(const struct fuse_context *fc,
-                          const int                  fd);
-int fuse_passthrough_close(const struct fuse_context *fc,
-                           const int                  backing_id);
-
 EXTERN_C_END

 #endif /* _FUSE_H_ */
@@ -37,7 +37,7 @@
 #endif

 #define FUSE_DEFAULT_MAX_PAGES_PER_REQ 32
-#define FUSE_DEFAULT_MAX_MAX_PAGES 256
+#define FUSE_MAX_MAX_PAGES 256

 EXTERN_C_BEGIN

@@ -46,8 +46,8 @@ EXTERN_C_BEGIN
 *
 * Changed in version 2.5
 */
-typedef struct fuse_file_info_t fuse_file_info_t;
-struct fuse_file_info_t
+struct
+fuse_file_info
 {
  /** Open flags. Available in open() and release() */
  int flags;
@@ -84,17 +84,10 @@ struct fuse_file_info_t

  uint32_t auto_cache : 1;

-  uint32_t parallel_direct_writes:1;
-
-  uint32_t noflush:1;
-  uint32_t passthrough:1;
-
  /** File handle.  May be filled in by filesystem in open().
      Available in all other file operations */
  uint64_t fh;

-  int32_t  backing_id;
-
  /** Lock owner id.  Available in locking operations and flush */
  uint64_t lock_owner;
 };
@@ -108,31 +101,31 @@ struct fuse_file_info_t
 * FUSE_CAP_EXPORT_SUPPORT: filesystem handles lookups of "." and ".."
 * FUSE_CAP_BIG_WRITES: filesystem can handle write size larger than 4kB
 * FUSE_CAP_DONT_MASK: don't apply umask to file mode on create operations
+ * FUSE_CAP_SPLICE_WRITE: ability to use splice() to write to the fuse device
+ * FUSE_CAP_SPLICE_MOVE: ability to move data to the fuse device with splice()
+ * FUSE_CAP_SPLICE_READ: ability to use splice() to read from the fuse device
 * FUSE_CAP_IOCTL_DIR: ioctl support on directories
 * FUSE_CAP_CACHE_SYMLINKS: cache READLINK responses
 */
-#define FUSE_CAP_ASYNC_READ           (1ULL << 0)
-#define FUSE_CAP_POSIX_LOCKS          (1ULL << 1)
-#define FUSE_CAP_ATOMIC_O_TRUNC       (1ULL << 3)
-#define FUSE_CAP_EXPORT_SUPPORT       (1ULL << 4)
-#define FUSE_CAP_BIG_WRITES           (1ULL << 5)
-#define FUSE_CAP_DONT_MASK            (1ULL << 6)
-#define FUSE_CAP_FLOCK_LOCKS          (1ULL << 10)
-#define FUSE_CAP_IOCTL_DIR            (1ULL << 11)
-#define FUSE_CAP_READDIR_PLUS         (1ULL << 13)
-#define FUSE_CAP_READDIR_PLUS_AUTO    (1ULL << 14)
-#define FUSE_CAP_ASYNC_DIO            (1ULL << 15)
-#define FUSE_CAP_WRITEBACK_CACHE      (1ULL << 16)
-#define FUSE_CAP_PARALLEL_DIROPS      (1ULL << 18)
-#define FUSE_CAP_POSIX_ACL            (1ULL << 19)
-#define FUSE_CAP_CACHE_SYMLINKS       (1ULL << 20)
-#define FUSE_CAP_MAX_PAGES            (1ULL << 21)
-#define FUSE_CAP_SETXATTR_EXT         (1ULL << 22)
-#define FUSE_CAP_DIRECT_IO_ALLOW_MMAP (1ULL << 23)
-#define FUSE_CAP_CREATE_SUPP_GROUP    (1ULL << 24)
-#define FUSE_CAP_PASSTHROUGH          (1ULL << 25)
-#define FUSE_CAP_HANDLE_KILLPRIV      (1ULL << 26)
-#define FUSE_CAP_HANDLE_KILLPRIV_V2   (1ULL << 27)
+#define FUSE_CAP_ASYNC_READ        (1 << 0)
+#define FUSE_CAP_POSIX_LOCKS       (1 << 1)
+#define FUSE_CAP_ATOMIC_O_TRUNC    (1 << 3)
+#define FUSE_CAP_EXPORT_SUPPORT    (1 << 4)
+#define FUSE_CAP_BIG_WRITES        (1 << 5)
+#define FUSE_CAP_DONT_MASK         (1 << 6)
+#define FUSE_CAP_SPLICE_WRITE      (1 << 7)
+#define FUSE_CAP_SPLICE_MOVE       (1 << 8)
+#define FUSE_CAP_SPLICE_READ       (1 << 9)
+#define FUSE_CAP_FLOCK_LOCKS       (1 << 10)
+#define FUSE_CAP_IOCTL_DIR         (1 << 11)
+#define FUSE_CAP_READDIR_PLUS      (1 << 13)
+#define FUSE_CAP_READDIR_PLUS_AUTO (1 << 14)
+#define FUSE_CAP_ASYNC_DIO         (1 << 15)
+#define FUSE_CAP_WRITEBACK_CACHE   (1 << 16)
+#define FUSE_CAP_PARALLEL_DIROPS   (1 << 18)
+#define FUSE_CAP_POSIX_ACL         (1 << 19)
+#define FUSE_CAP_CACHE_SYMLINKS    (1 << 20)
+#define FUSE_CAP_MAX_PAGES         (1 << 21)

 /**
 * Ioctl flags
@@ -158,23 +151,61 @@ struct fuse_file_info_t
 * indicate the value requested by the filesystem.  The requested
 * value must usually be smaller than the indicated value.
 */
-struct fuse_conn_info
-{
+struct fuse_conn_info {
+  /**
+   * Major version of the protocol (read-only)
+   */
  unsigned proto_major;
+
+  /**
+   * Minor version of the protocol (read-only)
+   */
  unsigned proto_minor;
+
+  /**
+   * Maximum size of the write buffer
+   */
  unsigned max_write;
+
+  /**
+   * Maximum readahead
+   */
  unsigned max_readahead;
-  uint64_t capable;
-  uint64_t want;
+
+  /**
+   * Capability flags, that the kernel supports
+   */
+  unsigned capable;
+
+  /**
+   * Capability flags, that the filesystem wants to enable
+   */
+  unsigned want;
+
+  /**
+   * Maximum number of backgrounded requests
+   */
  unsigned max_background;
+
+  /**
+   * Kernel congestion threshold parameter
+   */
  unsigned congestion_threshold;
+
+  /**
+   * Max pages
+   */
  uint16_t max_pages;
+
+  /**
+   * For future use.
+   */
+  unsigned reserved[22];
 };

 struct fuse_session;
 struct fuse_chan;
-struct fuse_pollhandle_t;
-typedef struct fuse_pollhandle_t fuse_pollhandle_t;
+struct fuse_pollhandle;

 /**
 * Create a FUSE mountpoint
@@ -240,7 +271,7 @@ int fuse_version(void);
 *
 * @param ph the poll handle
 */
-void fuse_pollhandle_destroy(fuse_pollhandle_t *ph);
+void fuse_pollhandle_destroy(struct fuse_pollhandle *ph);

 /* ----------------------------------------------------------- *
 * Data buffer						       *
@@ -249,14 +280,15 @@ void fuse_pollhandle_destroy(fuse_pollhandle_t *ph);
 /**
 * Buffer flags
 */
-enum fuse_buf_flags {
-  /**
+#define FUSE_BUF_FLAG_NONE (1 << 0)
+
+/**
   * Buffer contains a file descriptor
   *
   * If this flag is set, the .fd field is valid, otherwise the
   * .mem fields is valid.
   */
-  FUSE_BUF_IS_FD		= (1 << 1),
+#define FUSE_BUF_FLAG_IS_FD (1 << 1)

  /**
   * Seek on the file descriptor
@@ -265,7 +297,7 @@ enum fuse_buf_flags {
   * used to seek to the given offset before performing
   * operation on file descriptor.
   */
-  FUSE_BUF_FD_SEEK	= (1 << 2),
+#define FUSE_BUF_FLAG_FD_SEEK (1 << 2)

  /**
   * Retry operation on file descriptor
@@ -274,50 +306,50 @@ enum fuse_buf_flags {
   * until .size bytes have been copied or an error or EOF is
   * detected.
   */
-  FUSE_BUF_FD_RETRY	= (1 << 3),
-};
+#define FUSE_BUF_FLAG_FD_RETRY (1 << 3)

 /**
 * Buffer copy flags
 */
-enum fuse_buf_copy_flags {
-  /**
-   * Don't use splice(2)
-   *
-   * Always fall back to using read and write instead of
-   * splice(2) to copy data from one file descriptor to another.
-   *
-   * If this flag is not set, then only fall back if splice is
-   * unavailable.
-   */
-  FUSE_BUF_NO_SPLICE	= (1 << 1),
+#define FUSE_BUF_COPY_FLAG_NONE 0

-  /**
-   * Force splice
-   *
-   * Always use splice(2) to copy data from one file descriptor
-   * to another.  If splice is not available, return -EINVAL.
-   */
-  FUSE_BUF_FORCE_SPLICE	= (1 << 2),
+/**
+ * Don't use splice(2)
+ *
+ * Always fall back to using read and write instead of
+ * splice(2) to copy data from one file descriptor to another.
+ *
+ * If this flag is not set, then only fall back if splice is
+ * unavailable.
+ */
+#define FUSE_BUF_COPY_FLAG_NO_SPLICE (1 << 1)

-  /**
-   * Try to move data with splice.
-   *
-   * If splice is used, try to move pages from the source to the
-   * destination instead of copying.  See documentation of
-   * SPLICE_F_MOVE in splice(2) man page.
-   */
-  FUSE_BUF_SPLICE_MOVE	= (1 << 3),
+/**
+ * Force splice
+ *
+ * Always use splice(2) to copy data from one file descriptor
+ * to another.  If splice is not available, return -EINVAL.
+ */
+#define FUSE_BUF_COPY_FLAG_FORCE_SPLICE (1 << 2)
+
+/**
+ * Try to move data with splice.
+ *
+ * If splice is used, try to move pages from the source to the
+ * destination instead of copying.  See documentation of
+ * SPLICE_F_MOVE in splice(2) man page.
+ */
+#define FUSE_BUF_COPY_FLAG_SPLICE_MOVE (1 << 3)
+
+/**
+ * Don't block on the pipe when copying data with splice
+ *
+ * Makes the operations on the pipe non-blocking (if the pipe
+ * is full or empty).  See SPLICE_F_NONBLOCK in the splice(2)
+ * man page.
+ */
+#define FUSE_BUF_COPY_FLAG_SPLICE_NONBLOCK (1 << 4)

-  /**
-   * Don't block on the pipe when copying data with splice
-   *
-   * Makes the operations on the pipe non-blocking (if the pipe
-   * is full or empty).  See SPLICE_F_NONBLOCK in the splice(2)
-   * man page.
-   */
-  FUSE_BUF_SPLICE_NONBLOCK= (1 << 4),
-};

 /**
 * Single data buffer
@@ -334,14 +366,14 @@ struct fuse_buf {
  /**
   * Buffer flags
   */
-  enum fuse_buf_flags flags;
+  int flags;

  /**
   * Memory pointer
   *
   * Used unless FUSE_BUF_IS_FD flag is set.
   */
-  void *mem;
+  char *mem;

  /**
   * File descriptor
@@ -396,7 +428,7 @@ struct fuse_bufvec {
      /* .off =  */ 0,                                  \
      /* .buf =  */ { /* [0] = */ {			\
        /* .size =  */ (size__),                        \
-          /* .flags = */ (enum fuse_buf_flags) 0,	\
+          /* .flags = */ 0,	\
          /* .mem =   */ NULL,                          \
          /* .fd =    */ -1,                            \
          /* .pos =   */ 0,                             \
@@ -419,8 +451,7 @@ size_t fuse_buf_size(const struct fuse_bufvec *bufv);
 * @param flags flags controlling the copy
 * @return actual number of bytes copied or -errno on error
 */
-ssize_t fuse_buf_copy(struct fuse_bufvec *dst, struct fuse_bufvec *src,
-                      enum fuse_buf_copy_flags flags);
+ssize_t fuse_buf_copy(struct fuse_bufvec *dst, struct fuse_bufvec *src, int flags);

 /* ----------------------------------------------------------- *
 * Signal handling					       *
@@ -1,31 +0,0 @@
-/*
-  ISC License
-
-  Copyright (c) 2023, Antonio SJ Musumeci <trapexit@spawn.link>
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted, provided that the above
-  copyright notice and this permission notice appear in all copies.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-
-#pragma once
-
-#include <string>
-
-int         fuse_config_get_read_thread_count();
-int         fuse_config_get_process_thread_count();
-int         fuse_config_get_process_thread_queue_depth();
-std::string fuse_config_get_pin_threads();
-
-void        fuse_config_set_read_thread_count(int const);
-void        fuse_config_set_process_thread_count(int const);
-void        fuse_config_set_process_thread_queue_depth(int const);
-void        fuse_config_set_pin_threads(std::string const);
@@ -43,12 +43,14 @@ enum fuse_dirents_type_e
 };
 typedef enum fuse_dirents_type_e fuse_dirents_type_t;

-typedef struct fuse_dirents_t fuse_dirents_t;
-struct fuse_dirents_t
+typedef struct fuse_dirents_s fuse_dirents_t;
+struct fuse_dirents_s
 {
-  kvec_t(char)        data;
-  kvec_t(uint32_t)    offs;
-  fuse_dirents_type_t type;
+  char                *buf;
+  uint64_t             buf_len;
+  uint64_t             data_len;
+  kvec_t(uint32_t)     offs;
+  fuse_dirents_type_t  type;
 };

 int  fuse_dirents_init(fuse_dirents_t *d);
@@ -63,14 +65,14 @@ int  fuse_dirents_add_plus(fuse_dirents_t      *d,
                           const uint64_t       namelen,
                           const fuse_entry_t  *entry,
                           const struct stat   *st);
-int  fuse_dirents_add_linux(fuse_dirents_t         *d,
-                            const linux_dirent64_t *de,
-                            const uint64_t          namelen);
-int  fuse_dirents_add_linux_plus(fuse_dirents_t         *d,
-                                 const linux_dirent64_t *de,
-                                 const uint64_t          namelen,
-                                 const fuse_entry_t     *entry,
-                                 const struct stat      *st);
+int  fuse_dirents_add_linux(fuse_dirents_t              *d,
+                            const struct linux_dirent64 *de,
+                            const uint64_t               namelen);
+int  fuse_dirents_add_linux_plus(fuse_dirents_t              *d,
+                                 const struct linux_dirent64 *de,
+                                 const uint64_t               namelen,
+                                 const fuse_entry_t          *entry,
+                                 const struct stat           *st);

 void *fuse_dirents_find(fuse_dirents_t *d,
                        const uint64_t  ino);
@@ -172,63 +172,6 @@
 *  - add FUSE_WRITE_KILL_PRIV flag
 *  - add FUSE_SETUPMAPPING and FUSE_REMOVEMAPPING
 *  - add map_alignment to fuse_init_out, add FUSE_MAP_ALIGNMENT flag
- *
- *  7.32
- *  - add flags to fuse_attr, add FUSE_ATTR_SUBMOUNT, add FUSE_SUBMOUNTS
- *
- *  7.33
- *  - add FUSE_HANDLE_KILLPRIV_V2, FUSE_WRITE_KILL_SUIDGID, FATTR_KILL_SUIDGID
- *  - add FUSE_OPEN_KILL_SUIDGID
- *  - extend fuse_setxattr_in, add FUSE_SETXATTR_EXT
- *  - add FUSE_SETXATTR_ACL_KILL_SGID
- *
- *  7.34
- *  - add FUSE_SYNCFS
- *
- *  7.35
- *  - add FOPEN_NOFLUSH
- *
- *  7.36
- *  - extend fuse_init_in with reserved fields, add FUSE_INIT_EXT init flag
- *  - add flags2 to fuse_init_in and fuse_init_out
- *  - add FUSE_SECURITY_CTX init flag
- *  - add security context to create, mkdir, symlink, and mknod requests
- *  - add FUSE_HAS_INODE_DAX, FUSE_ATTR_DAX
- *
- *  7.37
- *  - add FUSE_TMPFILE
- *
- *  7.38
- *  - add FUSE_EXPIRE_ONLY flag to fuse_notify_inval_entry
- *  - add FOPEN_PARALLEL_DIRECT_WRITES
- *  - add total_extlen to fuse_in_header
- *  - add FUSE_MAX_NR_SECCTX
- *  - add extension header
- *  - add FUSE_EXT_GROUPS
- *  - add FUSE_CREATE_SUPP_GROUP
- *  - add FUSE_HAS_EXPIRE_ONLY
- *
- *  7.39
- *  - add FUSE_DIRECT_IO_ALLOW_MMAP
- *  - add FUSE_STATX and related structures
- *
- *  7.40
- *  - add max_stack_depth to fuse_init_out, add FUSE_PASSTHROUGH init flag
- *  - add backing_id to fuse_open_out, add FOPEN_PASSTHROUGH open flag
- *  - add FUSE_NO_EXPORT_SUPPORT init flag
- *  - add FUSE_NOTIFY_RESEND, add FUSE_HAS_RESEND init flag
- *
- *  7.41
- *  - add FUSE_ALLOW_IDMAP
- *  7.42
- *  - Add FUSE_OVER_IO_URING and all other io-uring related flags and data
- *    structures:
- *    - struct fuse_uring_ent_in_out
- *    - struct fuse_uring_req_header
- *    - struct fuse_uring_cmd_req
- *    - FUSE_URING_IN_OUT_HEADER_SZ
- *    - FUSE_URING_OP_IN_OUT_SZ
- *    - enum fuse_uring_cmd
 */

 #ifndef _LINUX_FUSE_H
@@ -264,7 +207,7 @@
 #define FUSE_KERNEL_VERSION 7

 /** Minor version number of this interface */
-#define FUSE_KERNEL_MINOR_VERSION 42
+#define FUSE_KERNEL_MINOR_VERSION 31

 /** The node ID of the root inode */
 #define FUSE_ROOT_ID 1
@@ -288,41 +231,7 @@ struct fuse_attr {
 	uint32_t	gid;
 	uint32_t	rdev;
 	uint32_t	blksize;
-	uint32_t	flags;
-};
-
-/*
- * The following structures are bit-for-bit compatible with the statx(2) ABI in
- * Linux.
- */
-struct fuse_sx_time {
-	int64_t		tv_sec;
-	uint32_t	tv_nsec;
-	int32_t		__reserved;
-};
-
-struct fuse_statx {
-	uint32_t	mask;
-	uint32_t	blksize;
-	uint64_t	attributes;
-	uint32_t	nlink;
-	uint32_t	uid;
-	uint32_t	gid;
-	uint16_t	mode;
-	uint16_t	__spare0[1];
-	uint64_t	ino;
-	uint64_t	size;
-	uint64_t	blocks;
-	uint64_t	attributes_mask;
-	struct fuse_sx_time	atime;
-	struct fuse_sx_time	btime;
-	struct fuse_sx_time	ctime;
-	struct fuse_sx_time	mtime;
-	uint32_t	rdev_major;
-	uint32_t	rdev_minor;
-	uint32_t	dev_major;
-	uint32_t	dev_minor;
-	uint64_t	__spare2[14];
+	uint32_t	padding;
 };

 struct fuse_kstatfs {
@@ -359,7 +268,6 @@ struct fuse_file_lock {
 #define FATTR_MTIME_NOW	(1 << 8)
 #define FATTR_LOCKOWNER	(1 << 9)
 #define FATTR_CTIME	(1 << 10)
-#define FATTR_KILL_SUIDGID	(1 << 11)

 /**
 * Flags returned by the OPEN request
@@ -369,18 +277,12 @@ struct fuse_file_lock {
 * FOPEN_NONSEEKABLE: the file is not seekable
 * FOPEN_CACHE_DIR: allow caching this directory
 * FOPEN_STREAM: the file is stream-like (no file position at all)
- * FOPEN_NOFLUSH: don't flush data cache on close (unless FUSE_WRITEBACK_CACHE)
- * FOPEN_PARALLEL_DIRECT_WRITES: Allow concurrent direct writes on the same inode
- * FOPEN_PASSTHROUGH: passthrough read/write io for this open file
 */
 #define FOPEN_DIRECT_IO		(1 << 0)
 #define FOPEN_KEEP_CACHE	(1 << 1)
 #define FOPEN_NONSEEKABLE	(1 << 2)
 #define FOPEN_CACHE_DIR		(1 << 3)
 #define FOPEN_STREAM		(1 << 4)
-#define FOPEN_NOFLUSH		(1 << 5)
-#define FOPEN_PARALLEL_DIRECT_WRITES	(1 << 6)
-#define FOPEN_PASSTHROUGH	(1 << 7)

 /**
 * INIT request/reply flags
@@ -411,77 +313,35 @@ struct fuse_file_lock {
 * FUSE_CACHE_SYMLINKS: cache READLINK responses
 * FUSE_NO_OPENDIR_SUPPORT: kernel supports zero-message opendir
 * FUSE_EXPLICIT_INVAL_DATA: only invalidate cached pages on explicit request
- * FUSE_MAP_ALIGNMENT: init_out.map_alignment contains log2(byte alignment) for
- *		       foffset and moffset fields in struct
- *		       fuse_setupmapping_out and fuse_removemapping_one.
- * FUSE_SUBMOUNTS: kernel supports auto-mounting directory submounts
- * FUSE_HANDLE_KILLPRIV_V2: fs kills suid/sgid/cap on write/chown/trunc.
- *			Upon write/truncate suid/sgid is only killed if caller
- *			does not have CAP_FSETID. Additionally upon
- *			write/truncate sgid is killed only if file has group
- *			execute permission. (Same as Linux VFS behavior).
- * FUSE_SETXATTR_EXT:	Server supports extended struct fuse_setxattr_in
- * FUSE_INIT_EXT: extended fuse_init_in request
- * FUSE_INIT_RESERVED: reserved, do not use
- * FUSE_SECURITY_CTX:	add security context to create, mkdir, symlink, and
- *			mknod
- * FUSE_HAS_INODE_DAX:  use per inode DAX
- * FUSE_CREATE_SUPP_GROUP: add supplementary group info to create, mkdir,
- *			symlink and mknod (single group that matches parent)
- * FUSE_HAS_EXPIRE_ONLY: kernel supports expiry-only entry invalidation
- * FUSE_DIRECT_IO_ALLOW_MMAP: allow shared mmap in FOPEN_DIRECT_IO mode.
- * FUSE_NO_EXPORT_SUPPORT: explicitly disable export support
- * FUSE_HAS_RESEND: kernel supports resending pending requests, and the high bit
- *		    of the request ID indicates resend requests
- * FUSE_ALLOW_IDMAP: allow creation of idmapped mounts
- * FUSE_OVER_IO_URING: Indicate that client supports io-uring
+ * FUSE_MAP_ALIGNMENT: map_alignment field is valid
 */
-#define FUSE_ASYNC_READ		(1ULL << 0)
-#define FUSE_POSIX_LOCKS	(1ULL << 1)
-#define FUSE_FILE_OPS		(1ULL << 2)
-#define FUSE_ATOMIC_O_TRUNC	(1ULL << 3)
-#define FUSE_EXPORT_SUPPORT	(1ULL << 4)
-#define FUSE_BIG_WRITES		(1ULL << 5)
-#define FUSE_DONT_MASK		(1ULL << 6)
-#define FUSE_SPLICE_WRITE	(1ULL << 7)
-#define FUSE_SPLICE_MOVE	(1ULL << 8)
-#define FUSE_SPLICE_READ	(1ULL << 9)
-#define FUSE_FLOCK_LOCKS	(1ULL << 10)
-#define FUSE_HAS_IOCTL_DIR	(1ULL << 11)
-#define FUSE_AUTO_INVAL_DATA	(1ULL << 12)
-#define FUSE_DO_READDIRPLUS	(1ULL << 13)
-#define FUSE_READDIRPLUS_AUTO	(1ULL << 14)
-#define FUSE_ASYNC_DIO		(1ULL << 15)
-#define FUSE_WRITEBACK_CACHE	(1ULL << 16)
-#define FUSE_NO_OPEN_SUPPORT	(1ULL << 17)
-#define FUSE_PARALLEL_DIROPS    (1ULL << 18)
-#define FUSE_HANDLE_KILLPRIV	(1ULL << 19)
-#define FUSE_POSIX_ACL		(1ULL << 20)
-#define FUSE_ABORT_ERROR	(1ULL << 21)
-#define FUSE_MAX_PAGES		(1ULL << 22)
-#define FUSE_CACHE_SYMLINKS	(1ULL << 23)
-#define FUSE_NO_OPENDIR_SUPPORT (1ULL << 24)
-#define FUSE_EXPLICIT_INVAL_DATA (1ULL << 25)
-#define FUSE_MAP_ALIGNMENT	(1ULL << 26)
-#define FUSE_SUBMOUNTS		(1ULL << 27)
-#define FUSE_HANDLE_KILLPRIV_V2	(1ULL << 28)
-#define FUSE_SETXATTR_EXT	(1ULL << 29)
-#define FUSE_INIT_EXT		(1ULL << 30)
-#define FUSE_INIT_RESERVED	(1ULL << 31)
-/* bits 32..63 get shifted down 32 bits into the flags2 field */
-#define FUSE_SECURITY_CTX	(1ULL << 32)
-#define FUSE_HAS_INODE_DAX	(1ULL << 33)
-#define FUSE_CREATE_SUPP_GROUP	(1ULL << 34)
-#define FUSE_HAS_EXPIRE_ONLY	(1ULL << 35)
-#define FUSE_DIRECT_IO_ALLOW_MMAP (1ULL << 36)
-#define FUSE_PASSTHROUGH	(1ULL << 37)
-#define FUSE_NO_EXPORT_SUPPORT	(1ULL << 38)
-#define FUSE_HAS_RESEND		(1ULL << 39)
-
-/* Obsolete alias for FUSE_DIRECT_IO_ALLOW_MMAP */
-#define FUSE_DIRECT_IO_RELAX	FUSE_DIRECT_IO_ALLOW_MMAP
-#define FUSE_ALLOW_IDMAP	(1ULL << 40)
-#define FUSE_OVER_IO_URING	(1ULL << 41)
+#define FUSE_ASYNC_READ		(1 << 0)
+#define FUSE_POSIX_LOCKS	(1 << 1)
+#define FUSE_FILE_OPS		(1 << 2)
+#define FUSE_ATOMIC_O_TRUNC	(1 << 3)
+#define FUSE_EXPORT_SUPPORT	(1 << 4)
+#define FUSE_BIG_WRITES		(1 << 5)
+#define FUSE_DONT_MASK		(1 << 6)
+#define FUSE_SPLICE_WRITE	(1 << 7)
+#define FUSE_SPLICE_MOVE	(1 << 8)
+#define FUSE_SPLICE_READ	(1 << 9)
+#define FUSE_FLOCK_LOCKS	(1 << 10)
+#define FUSE_HAS_IOCTL_DIR	(1 << 11)
+#define FUSE_AUTO_INVAL_DATA	(1 << 12)
+#define FUSE_DO_READDIRPLUS	(1 << 13)
+#define FUSE_READDIRPLUS_AUTO	(1 << 14)
+#define FUSE_ASYNC_DIO		(1 << 15)
+#define FUSE_WRITEBACK_CACHE	(1 << 16)
+#define FUSE_NO_OPEN_SUPPORT	(1 << 17)
+#define FUSE_PARALLEL_DIROPS    (1 << 18)
+#define FUSE_HANDLE_KILLPRIV	(1 << 19)
+#define FUSE_POSIX_ACL		(1 << 20)
+#define FUSE_ABORT_ERROR	(1 << 21)
+#define FUSE_MAX_PAGES		(1 << 22)
+#define FUSE_CACHE_SYMLINKS	(1 << 23)
+#define FUSE_NO_OPENDIR_SUPPORT (1 << 24)
+#define FUSE_EXPLICIT_INVAL_DATA (1 << 25)
+#define FUSE_MAP_ALIGNMENT	(1 << 26)

 /**
 * CUSE INIT request/reply flags
@@ -511,14 +371,11 @@ struct fuse_file_lock {
 *
 * FUSE_WRITE_CACHE: delayed write from page cache, file handle is guessed
 * FUSE_WRITE_LOCKOWNER: lock_owner field is valid
- * FUSE_WRITE_KILL_SUIDGID: kill suid and sgid bits
+ * FUSE_WRITE_KILL_PRIV: kill suid and sgid bits
 */
 #define FUSE_WRITE_CACHE	(1 << 0)
 #define FUSE_WRITE_LOCKOWNER	(1 << 1)
-#define FUSE_WRITE_KILL_SUIDGID (1 << 2)
-
-/* Obsolete alias; this flag implies killing suid/sgid only. */
-#define FUSE_WRITE_KILL_PRIV	FUSE_WRITE_KILL_SUIDGID
+#define FUSE_WRITE_KILL_PRIV	(1 << 2)

 /**
 * Read flags
@@ -560,44 +417,6 @@ struct fuse_file_lock {
 */
 #define FUSE_FSYNC_FDATASYNC	(1 << 0)

-/**
- * fuse_attr flags
- *
- * FUSE_ATTR_SUBMOUNT: Object is a submount root
- * FUSE_ATTR_DAX: Enable DAX for this file in per inode DAX mode
- */
-#define FUSE_ATTR_SUBMOUNT      (1 << 0)
-#define FUSE_ATTR_DAX		(1 << 1)
-
-/**
- * Open flags
- * FUSE_OPEN_KILL_SUIDGID: Kill suid and sgid if executable
- */
-#define FUSE_OPEN_KILL_SUIDGID	(1 << 0)
-
-/**
- * setxattr flags
- * FUSE_SETXATTR_ACL_KILL_SGID: Clear SGID when system.posix_acl_access is set
- */
-#define FUSE_SETXATTR_ACL_KILL_SGID	(1 << 0)
-
-/**
- * notify_inval_entry flags
- * FUSE_EXPIRE_ONLY
- */
-#define FUSE_EXPIRE_ONLY		(1 << 0)
-
-/**
- * extension type
- * FUSE_MAX_NR_SECCTX: maximum value of &fuse_secctx_header.nr_secctx
- * FUSE_EXT_GROUPS: &fuse_supp_groups extension
- */
-enum fuse_ext_type {
-	/* Types 0..31 are reserved for fuse_secctx_header */
-	FUSE_MAX_NR_SECCTX	= 31,
-	FUSE_EXT_GROUPS		= 32,
-};
-
 enum fuse_opcode {
 	FUSE_LOOKUP		= 1,
 	FUSE_FORGET		= 2,  /* no reply */
@@ -646,9 +465,6 @@ enum fuse_opcode {
 	FUSE_COPY_FILE_RANGE	= 47,
 	FUSE_SETUPMAPPING	= 48,
 	FUSE_REMOVEMAPPING	= 49,
-	FUSE_SYNCFS		= 50,
-	FUSE_TMPFILE		= 51,
-	FUSE_STATX		= 52,

 	/* CUSE specific operations */
 	CUSE_INIT		= 4096,
@@ -665,7 +481,6 @@ enum fuse_notify_code {
 	FUSE_NOTIFY_STORE = 4,
 	FUSE_NOTIFY_RETRIEVE = 5,
 	FUSE_NOTIFY_DELETE = 6,
-	FUSE_NOTIFY_RESEND = 7,
 	FUSE_NOTIFY_CODE_MAX,
 };

@@ -714,22 +529,6 @@ struct fuse_attr_out {
 	struct fuse_attr attr;
 };

-struct fuse_statx_in {
-	uint32_t	getattr_flags;
-	uint32_t	reserved;
-	uint64_t	fh;
-	uint32_t	sx_flags;
-	uint32_t	sx_mask;
-};
-
-struct fuse_statx_out {
-	uint64_t	attr_valid;	/* Cache timeout for the attributes */
-	uint32_t	attr_valid_nsec;
-	uint32_t	flags;
-	uint64_t	spare[2];
-	struct fuse_statx stat;
-};
-
 #define FUSE_COMPAT_MKNOD_IN_SIZE 8

 struct fuse_mknod_in {
@@ -779,20 +578,20 @@ struct fuse_setattr_in {

 struct fuse_open_in {
 	uint32_t	flags;
-	uint32_t	open_flags;	/* FUSE_OPEN_... */
+	uint32_t	unused;
 };

 struct fuse_create_in {
 	uint32_t	flags;
 	uint32_t	mode;
 	uint32_t	umask;
-	uint32_t	open_flags;	/* FUSE_OPEN_... */
+	uint32_t	padding;
 };

 struct fuse_open_out {
 	uint64_t	fh;
 	uint32_t	open_flags;
-	int32_t		backing_id;
+	uint32_t	padding;
 };

 struct fuse_release_in {
@@ -848,13 +647,9 @@ struct fuse_fsync_in {
 	uint32_t	padding;
 };

-#define FUSE_COMPAT_SETXATTR_IN_SIZE 8
-
 struct fuse_setxattr_in {
 	uint32_t	size;
 	uint32_t	flags;
-	uint32_t	setxattr_flags;
-	uint32_t	padding;
 };

 struct fuse_getxattr_in {
@@ -889,8 +684,6 @@ struct fuse_init_in {
 	uint32_t	minor;
 	uint32_t	max_readahead;
 	uint32_t	flags;
-	uint32_t	flags2;
-	uint32_t	unused[11];
 };

 #define FUSE_COMPAT_INIT_OUT_SIZE 8
@@ -907,9 +700,7 @@ struct fuse_init_out {
 	uint32_t	time_gran;
 	uint16_t	max_pages;
 	uint16_t	map_alignment;
-	uint32_t	flags2;
-	uint32_t	max_stack_depth;
-	uint32_t	unused[6];
+	uint32_t	unused[8];
 };

 #define CUSE_INIT_INFO_MAX 4096
@@ -992,29 +783,6 @@ struct fuse_fallocate_in {
 	uint32_t	padding;
 };

-/**
- * FUSE request unique ID flag
- *
- * Indicates whether this is a resend request. The receiver should handle this
- * request accordingly.
- */
-#define FUSE_UNIQUE_RESEND (1ULL << 63)
-
-/**
- * This value will be set by the kernel to
- * (struct fuse_in_header).{uid,gid} fields in
- * case when:
- * - fuse daemon enabled FUSE_ALLOW_IDMAP
- * - idmapping information is not available and uid/gid
- *   can not be mapped in accordance with an idmapping.
- *
- * Note: an idmapping information always available
- * for inode creation operations like:
- * FUSE_MKNOD, FUSE_SYMLINK, FUSE_MKDIR, FUSE_TMPFILE,
- * FUSE_CREATE and FUSE_RENAME2 (with RENAME_WHITEOUT).
- */
-#define FUSE_INVALID_UIDGID ((uint32_t)(-1))
-
 struct fuse_in_header {
 	uint32_t	len;
 	uint32_t	opcode;
@@ -1023,8 +791,7 @@ struct fuse_in_header {
 	uint32_t	uid;
 	uint32_t	gid;
 	uint32_t	pid;
-	uint16_t	total_extlen; /* length of extensions in 8byte units */
-	uint16_t	padding;
+	uint32_t	padding;
 };

 struct fuse_out_header {
@@ -1041,12 +808,9 @@ struct fuse_dirent {
 	char name[];
 };

-/* Align variable length records to 64bit boundary */
-#define FUSE_REC_ALIGN(x) \
-	(((x) + sizeof(uint64_t) - 1) & ~(sizeof(uint64_t) - 1))
-
 #define FUSE_NAME_OFFSET offsetof(struct fuse_dirent, name)
-#define FUSE_DIRENT_ALIGN(x) FUSE_REC_ALIGN(x)
+#define FUSE_DIRENT_ALIGN(x) \
+	(((x) + sizeof(uint64_t) - 1) & ~(sizeof(uint64_t) - 1))
 #define FUSE_DIRENT_SIZE(d) \
 	FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)

@@ -1069,7 +833,7 @@ struct fuse_notify_inval_inode_out {
 struct fuse_notify_inval_entry_out {
 	uint64_t	parent;
 	uint32_t	namelen;
-	uint32_t	flags;
+	uint32_t	padding;
 };

 struct fuse_notify_delete_out {
@@ -1104,18 +868,8 @@ struct fuse_notify_retrieve_in {
 	uint64_t	dummy4;
 };

-struct fuse_backing_map {
-	int32_t		fd;
-	uint32_t	flags;
-	uint64_t	padding;
-};
-
 /* Device ioctls: */
-#define FUSE_DEV_IOC_MAGIC		229
-#define FUSE_DEV_IOC_CLONE		_IOR(FUSE_DEV_IOC_MAGIC, 0, uint32_t)
-#define FUSE_DEV_IOC_BACKING_OPEN	_IOW(FUSE_DEV_IOC_MAGIC, 1, \
-					     struct fuse_backing_map)
-#define FUSE_DEV_IOC_BACKING_CLOSE	_IOW(FUSE_DEV_IOC_MAGIC, 2, uint32_t)
+#define FUSE_DEV_IOC_CLONE	_IOR(229, 0, uint32_t)

 struct fuse_lseek_in {
 	uint64_t	fh;
@@ -1138,146 +892,4 @@ struct fuse_copy_file_range_in {
 	uint64_t	flags;
 };

-#define FUSE_SETUPMAPPING_FLAG_WRITE (1ull << 0)
-#define FUSE_SETUPMAPPING_FLAG_READ (1ull << 1)
-struct fuse_setupmapping_in {
-	/* An already open handle */
-	uint64_t	fh;
-	/* Offset into the file to start the mapping */
-	uint64_t	foffset;
-	/* Length of mapping required */
-	uint64_t	len;
-	/* Flags, FUSE_SETUPMAPPING_FLAG_* */
-	uint64_t	flags;
-	/* Offset in Memory Window */
-	uint64_t	moffset;
-};
-
-struct fuse_removemapping_in {
-	/* number of fuse_removemapping_one follows */
-	uint32_t        count;
-};
-
-struct fuse_removemapping_one {
-	/* Offset into the dax window start the unmapping */
-	uint64_t        moffset;
-	/* Length of mapping required */
-	uint64_t	len;
-};
-
-#define FUSE_REMOVEMAPPING_MAX_ENTRY   \
-		(PAGE_SIZE / sizeof(struct fuse_removemapping_one))
-
-struct fuse_syncfs_in {
-	uint64_t	padding;
-};
-
-/*
- * For each security context, send fuse_secctx with size of security context
- * fuse_secctx will be followed by security context name and this in turn
- * will be followed by actual context label.
- * fuse_secctx, name, context
- */
-struct fuse_secctx {
-	uint32_t	size;
-	uint32_t	padding;
-};
-
-/*
- * Contains the information about how many fuse_secctx structures are being
- * sent and what's the total size of all security contexts (including
- * size of fuse_secctx_header).
- *
- */
-struct fuse_secctx_header {
-	uint32_t	size;
-	uint32_t	nr_secctx;
-};
-
-/**
- * struct fuse_ext_header - extension header
- * @size: total size of this extension including this header
- * @type: type of extension
- *
- * This is made compatible with fuse_secctx_header by using type values >
- * FUSE_MAX_NR_SECCTX
- */
-struct fuse_ext_header {
-	uint32_t	size;
-	uint32_t	type;
-};
-
-/**
- * struct fuse_supp_groups - Supplementary group extension
- * @nr_groups: number of supplementary groups
- * @groups: flexible array of group IDs
- */
-struct fuse_supp_groups {
-	uint32_t	nr_groups;
-	uint32_t	groups[];
-};
-
-/**
- * Size of the ring buffer header
- */
-#define FUSE_URING_IN_OUT_HEADER_SZ 128
-#define FUSE_URING_OP_IN_OUT_SZ 128
-
-/* Used as part of the fuse_uring_req_header */
-struct fuse_uring_ent_in_out {
-	uint64_t flags;
-
-	/*
-	 * commit ID to be used in a reply to a ring request (see also
-	 * struct fuse_uring_cmd_req)
-	 */
-	uint64_t commit_id;
-
-	/* size of user payload buffer */
-	uint32_t payload_sz;
-	uint32_t padding;
-
-	uint64_t reserved;
-};
-
-/**
- * Header for all fuse-io-uring requests
- */
-struct fuse_uring_req_header {
-	/* struct fuse_in_header / struct fuse_out_header */
-	char in_out[FUSE_URING_IN_OUT_HEADER_SZ];
-
-	/* per op code header */
-	char op_in[FUSE_URING_OP_IN_OUT_SZ];
-
-	struct fuse_uring_ent_in_out ring_ent_in_out;
-};
-
-/**
- * sqe commands to the kernel
- */
-enum fuse_uring_cmd {
-	FUSE_IO_URING_CMD_INVALID = 0,
-
-	/* register the request buffer and fetch a fuse request */
-	FUSE_IO_URING_CMD_REGISTER = 1,
-
-	/* commit fuse request result and fetch next request */
-	FUSE_IO_URING_CMD_COMMIT_AND_FETCH = 2,
-};
-
-/**
- * In the 80B command area of the SQE.
- */
-struct fuse_uring_cmd_req {
-	uint64_t flags;
-
-	/* entry identifier for commits */
-	uint64_t commit_id;
-
-	/* queue the command is for (queue index) */
-	uint16_t qid;
-	uint8_t padding[6];
-};
-
 #endif /* _LINUX_FUSE_H */
@@ -1,10 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-
-typedef struct fuse_msgbuf_t fuse_msgbuf_t;
-struct fuse_msgbuf_t
-{
-  uint32_t  size;
-  char     *mem;
-};
@@ -1,14 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-
-struct fuse_chan;
-struct fuse_ll;
-
-typedef struct fuse_pollhandle_t fuse_pollhandle_t;
-struct fuse_pollhandle_t
-{
-  uint64_t kh;
-  struct fuse_chan *ch;
-  struct fuse_ll *f;
-};
@@ -1,346 +0,0 @@
-#ifndef _ANY_INVOKABLE_H_
-#define _ANY_INVOKABLE_H_
-
-#include <functional>
-#include <memory>
-#include <type_traits>
-
-// clang-format off
-/*
-namespace std {
-  template<class Sig> class any_invocable; // never defined
-
-  template<class R, class... ArgTypes>
-  class any_invocable<R(ArgTypes...) cv ref noexcept(noex)> {
-  public:
-    using result_type = R;
-
-    // SECTION.3, construct/copy/destroy
-    any_invocable() noexcept;
-    any_invocable(nullptr_t) noexcept;
-    any_invocable(any_invocable&&) noexcept;
-    template<class F> any_invocable(F&&);
-
-    template<class T, class... Args>
-      explicit any_invocable(in_place_type_t<T>, Args&&...);
-    template<class T, class U, class... Args>
-      explicit any_invocable(in_place_type_t<T>, initializer_list<U>, Args&&...);
-
-    any_invocable& operator=(any_invocable&&) noexcept;
-    any_invocable& operator=(nullptr_t) noexcept;
-    template<class F> any_invocable& operator=(F&&);
-    template<class F> any_invocable& operator=(reference_wrapper<F>) noexcept;
-
-    ~any_invocable();
-
-    // SECTION.4, any_invocable modifiers
-    void swap(any_invocable&) noexcept;
-
-    // SECTION.5, any_invocable capacity
-    explicit operator bool() const noexcept;
-
-    // SECTION.6, any_invocable invocation
-    R operator()(ArgTypes...) cv ref noexcept(noex);
-
-    // SECTION.7, null pointer comparisons
-    friend bool operator==(const any_invocable&, nullptr_t) noexcept;
-
-    // SECTION.8, specialized algorithms
-    friend void swap(any_invocable&, any_invocable&) noexcept;
-  };
-}
-*/
-// clang-format on
-
-namespace ofats {
-
-namespace any_detail {
-
-using buffer = std::aligned_storage_t<sizeof(void*) * 2, alignof(void*)>;
-
-template <class T>
-inline constexpr bool is_small_object_v =
-    sizeof(T) <= sizeof(buffer) && alignof(buffer) % alignof(T) == 0 &&
-    std::is_nothrow_move_constructible_v<T>;
-
-union storage {
-  void* ptr_ = nullptr;
-  buffer buf_;
-};
-
-enum class action { destroy, move };
-
-template <class R, class... ArgTypes>
-struct handler_traits {
-  template <class Derived>
-  struct handler_base {
-    static void handle(action act, storage* current, storage* other = nullptr) {
-      switch (act) {
-        case (action::destroy):
-          Derived::destroy(*current);
-          break;
-        case (action::move):
-          Derived::move(*current, *other);
-          break;
-      }
-    }
-  };
-
-  template <class T>
-  struct small_handler : handler_base<small_handler<T>> {
-    template <class... Args>
-    static void create(storage& s, Args&&... args) {
-      new (static_cast<void*>(&s.buf_)) T(std::forward<Args>(args)...);
-    }
-
-    static void destroy(storage& s) noexcept {
-      T& value = *static_cast<T*>(static_cast<void*>(&s.buf_));
-      value.~T();
-    }
-
-    static void move(storage& dst, storage& src) noexcept {
-      create(dst, std::move(*static_cast<T*>(static_cast<void*>(&src.buf_))));
-      destroy(src);
-    }
-
-    static R call(const storage& s, ArgTypes... args) {
-      return std::invoke(
-          *static_cast<T*>(static_cast<void*>(&const_cast<storage&>(s).buf_)),
-          std::forward<ArgTypes>(args)...);
-    }
-  };
-
-  template <class T>
-  struct large_handler : handler_base<large_handler<T>> {
-    template <class... Args>
-    static void create(storage& s, Args&&... args) {
-      s.ptr_ = new T(std::forward<Args>(args)...);
-    }
-
-    static void destroy(storage& s) noexcept { delete static_cast<T*>(s.ptr_); }
-
-    static void move(storage& dst, storage& src) noexcept {
-      dst.ptr_ = src.ptr_;
-    }
-
-    static R call(const storage& s, ArgTypes... args) {
-      return std::invoke(*static_cast<T*>(s.ptr_),
-                         std::forward<ArgTypes>(args)...);
-    }
-  };
-
-  template <class T>
-  using handler = std::conditional_t<is_small_object_v<T>, small_handler<T>,
-                                     large_handler<T>>;
-};
-
-template <class T>
-struct is_in_place_type : std::false_type {};
-
-template <class T>
-struct is_in_place_type<std::in_place_type_t<T>> : std::true_type {};
-
-template <class T>
-inline constexpr auto is_in_place_type_v = is_in_place_type<T>::value;
-
-template <class R, bool is_noexcept, class... ArgTypes>
-class any_invocable_impl {
-  template <class T>
-  using handler =
-      typename any_detail::handler_traits<R, ArgTypes...>::template handler<T>;
-
-  using storage = any_detail::storage;
-  using action = any_detail::action;
-  using handle_func = void (*)(any_detail::action, any_detail::storage*,
-                               any_detail::storage*);
-  using call_func = R (*)(const any_detail::storage&, ArgTypes...);
-
- public:
-  using result_type = R;
-
-  any_invocable_impl() noexcept = default;
-  any_invocable_impl(std::nullptr_t) noexcept {}
-  any_invocable_impl(any_invocable_impl&& rhs) noexcept {
-    if (rhs.handle_) {
-      handle_ = rhs.handle_;
-      handle_(action::move, &storage_, &rhs.storage_);
-      call_ = rhs.call_;
-      rhs.handle_ = nullptr;
-    }
-  }
-
-  any_invocable_impl& operator=(any_invocable_impl&& rhs) noexcept {
-    any_invocable_impl{std::move(rhs)}.swap(*this);
-    return *this;
-  }
-  any_invocable_impl& operator=(std::nullptr_t) noexcept {
-    destroy();
-    return *this;
-  }
-
-  ~any_invocable_impl() { destroy(); }
-
-  void swap(any_invocable_impl& rhs) noexcept {
-    if (handle_) {
-      if (rhs.handle_) {
-        storage tmp;
-        handle_(action::move, &tmp, &storage_);
-        rhs.handle_(action::move, &storage_, &rhs.storage_);
-        handle_(action::move, &rhs.storage_, &tmp);
-        std::swap(handle_, rhs.handle_);
-        std::swap(call_, rhs.call_);
-      } else {
-        rhs.swap(*this);
-      }
-    } else if (rhs.handle_) {
-      rhs.handle_(action::move, &storage_, &rhs.storage_);
-      handle_ = rhs.handle_;
-      call_ = rhs.call_;
-      rhs.handle_ = nullptr;
-    }
-  }
-
-  explicit operator bool() const noexcept { return handle_ != nullptr; }
-
- protected:
-  template <class F, class... Args>
-  void create(Args&&... args) {
-    using hdl = handler<F>;
-    hdl::create(storage_, std::forward<Args>(args)...);
-    handle_ = &hdl::handle;
-    call_ = &hdl::call;
-  }
-
-  void destroy() noexcept {
-    if (handle_) {
-      handle_(action::destroy, &storage_, nullptr);
-      handle_ = nullptr;
-    }
-  }
-
-  R call(ArgTypes... args) const noexcept(is_noexcept) {
-    return call_(storage_, std::forward<ArgTypes>(args)...);
-  }
-
-  friend bool operator==(const any_invocable_impl& f, std::nullptr_t) noexcept {
-    return !f;
-  }
-  friend bool operator==(std::nullptr_t, const any_invocable_impl& f) noexcept {
-    return !f;
-  }
-  friend bool operator!=(const any_invocable_impl& f, std::nullptr_t) noexcept {
-    return static_cast<bool>(f);
-  }
-  friend bool operator!=(std::nullptr_t, const any_invocable_impl& f) noexcept {
-    return static_cast<bool>(f);
-  }
-
-  friend void swap(any_invocable_impl& lhs, any_invocable_impl& rhs) noexcept {
-    lhs.swap(rhs);
-  }
-
- private:
-  storage storage_;
-  handle_func handle_ = nullptr;
-  call_func call_;
-};
-
-template <class T>
-using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
-
-template <class AI, class F, bool noex, class R, class FCall, class... ArgTypes>
-using can_convert = std::conjunction<
-    std::negation<std::is_same<remove_cvref_t<F>, AI>>,
-    std::negation<any_detail::is_in_place_type<remove_cvref_t<F>>>,
-    std::is_invocable_r<R, FCall, ArgTypes...>,
-    std::bool_constant<(!noex ||
-                        std::is_nothrow_invocable_r_v<R, FCall, ArgTypes...>)>,
-    std::is_constructible<std::decay_t<F>, F>>;
-
-}  // namespace any_detail
-
-template <class Signature>
-class any_invocable;
-
-#define __OFATS_ANY_INVOCABLE(cv, ref, noex, inv_quals)                        \
-  template <class R, class... ArgTypes>                                        \
-  class any_invocable<R(ArgTypes...) cv ref noexcept(noex)> final              \
-      : public any_detail::any_invocable_impl<R, noex, ArgTypes...> {          \
-    using base_type = any_detail::any_invocable_impl<R, noex, ArgTypes...>;    \
-                                                                               \
-   public:                                                                     \
-    using base_type::base_type;                                                \
-                                                                               \
-    template <                                                                 \
-        class F,                                                               \
-        class = std::enable_if_t<any_detail::can_convert<                      \
-            any_invocable, F, noex, R, F inv_quals, ArgTypes...>::value>>      \
-    any_invocable(F&& f) {                                                     \
-      base_type::template create<std::decay_t<F>>(std::forward<F>(f));         \
-    }                                                                          \
-                                                                               \
-    template <class T, class... Args, class VT = std::decay_t<T>,              \
-              class = std::enable_if_t<                                        \
-                  std::is_move_constructible_v<VT> &&                          \
-                  std::is_constructible_v<VT, Args...> &&                      \
-                  std::is_invocable_r_v<R, VT inv_quals, ArgTypes...> &&       \
-                  (!noex || std::is_nothrow_invocable_r_v<R, VT inv_quals,     \
-                                                          ArgTypes...>)>>      \
-    explicit any_invocable(std::in_place_type_t<T>, Args&&... args) {          \
-      base_type::template create<VT>(std::forward<Args>(args)...);             \
-    }                                                                          \
-                                                                               \
-    template <                                                                 \
-        class T, class U, class... Args, class VT = std::decay_t<T>,           \
-        class = std::enable_if_t<                                              \
-            std::is_move_constructible_v<VT> &&                                \
-            std::is_constructible_v<VT, std::initializer_list<U>&, Args...> && \
-            std::is_invocable_r_v<R, VT inv_quals, ArgTypes...> &&             \
-            (!noex ||                                                          \
-             std::is_nothrow_invocable_r_v<R, VT inv_quals, ArgTypes...>)>>    \
-    explicit any_invocable(std::in_place_type_t<T>,                            \
-                           std::initializer_list<U> il, Args&&... args) {      \
-      base_type::template create<VT>(il, std::forward<Args>(args)...);         \
-    }                                                                          \
-                                                                               \
-    template <class F, class FDec = std::decay_t<F>>                           \
-    std::enable_if_t<!std::is_same_v<FDec, any_invocable> &&                   \
-                         std::is_move_constructible_v<FDec>,                   \
-                     any_invocable&>                                           \
-    operator=(F&& f) {                                                         \
-      any_invocable{std::forward<F>(f)}.swap(*this);                           \
-      return *this;                                                            \
-    }                                                                          \
-    template <class F>                                                         \
-    any_invocable& operator=(std::reference_wrapper<F> f) {                    \
-      any_invocable{f}.swap(*this);                                            \
-      return *this;                                                            \
-    }                                                                          \
-                                                                               \
-    R operator()(ArgTypes... args) cv ref noexcept(noex) {                     \
-      return base_type::call(std::forward<ArgTypes>(args)...);                 \
-    }                                                                          \
-  }
-
-// cv -> {`empty`, const}
-// ref -> {`empty`, &, &&}
-// noex -> {true, false}
-// inv_quals -> (is_empty(ref) ? & : ref)
-__OFATS_ANY_INVOCABLE(, , false, &);               // 000
-__OFATS_ANY_INVOCABLE(, , true, &);                // 001
-__OFATS_ANY_INVOCABLE(, &, false, &);              // 010
-__OFATS_ANY_INVOCABLE(, &, true, &);               // 011
-__OFATS_ANY_INVOCABLE(, &&, false, &&);            // 020
-__OFATS_ANY_INVOCABLE(, &&, true, &&);             // 021
-__OFATS_ANY_INVOCABLE(const, , false, const&);     // 100
-__OFATS_ANY_INVOCABLE(const, , true, const&);      // 101
-__OFATS_ANY_INVOCABLE(const, &, false, const&);    // 110
-__OFATS_ANY_INVOCABLE(const, &, true, const&);     // 111
-__OFATS_ANY_INVOCABLE(const, &&, false, const&&);  // 120
-__OFATS_ANY_INVOCABLE(const, &&, true, const&&);   // 121
-
-#undef __OFATS_ANY_INVOCABLE
-
-}  // namespace ofats
-
-#endif  // _ANY_INVOKABLE_H_
@@ -59,10 +59,6 @@
 #define kv_pop(v) ((v).a[--(v).n])
 #define kv_size(v) ((v).n)
 #define kv_max(v) ((v).m)
-#define kv_first(v) (kv_A(v,0))
-#define kv_last(v) (kv_A(v,kv_size(v)-1))
-#define kv_end(v) (kv_A(v,kv_size(v)))
-#define kv_delete(v,i) (kv_A(v,i) = kv_pop(v))

 #define kv_resize(type, v, s)  ((v).m = (s), (v).a = (type*)realloc((v).a, sizeof(type) * (v).m))

@@ -1,12 +1,8 @@
 #pragma once

 #include <stdint.h>
-#include <string.h>

-#define DIRENT_NAMELEN(X) (strlen((X)->name))
-
-typedef struct linux_dirent64_t linux_dirent64_t;
-struct linux_dirent64_t
+struct linux_dirent64
 {
  uint64_t ino;
  int64_t  off;
--- a/Show More
+++ b/Show More